2. 事务处理三步曲：(事务是一个边界) ① connection.setAutoCommit(false); //把自动提交关闭；在创建Statement对象之前。 ② 正常的DB操作 //若有一条SQL语句失败了，自动回滚 ③ connection.commit() //主动提交 和 connection.rollback() //主动回滚，一般写在catch语句里，而前三个都写在try语句里
六、SQL 3.0规范中的新类型： Blob，大的二进制数据文件，最多存储2G。 Clob，大文本文件对象，最多存储2G。 在使用上述大对象的时候，在使用JDBC插入记录时要先插入一个空的占位对象， "insert into tableName valuse(?,?,empty_blob())"//在数据库制造一个空的blob对象字段值 然后使用"select blobdata from t_blob where id = ? for update"对获得的大对象进行实际的写入操作 Blod通过getBinaryOutputStream()方法获取流进行写入。 getBinaryStream()方法获得流来获取Blob中存储的数据。 Clob的操作也和、Blob相同。 getAsciiStream()用于读取存储的文本对象，getAsciiOutputStream()方法之获得流用来向文件对象写入的。
BLOB与CLOB的异同点： ① 都可以存储大量超长的数据； ② BLOB (Binary Large Object) 以二进制格式保存，特别适合保存图片、视频文件、音频文件、程序文件等； ③ CLOB (Character Large Object) 以Character格式保存于数据库中，适合保存比较长的文本文件。
注意：(个人归结的) 循环体内申明的变量，在循环体结束后立即释放，循环体外无法使用。 但在另外一个循环体内可以再次申明一个跟前面同名的变量，互相不影响。 如for内定义的 i： for(int i=0;i<10;i++){...} 则在上式 for 循环结束后无法再调用 i 值，还会报错。 for(int i=0;i<10;i++){...} 和后面的 for(int i=0;i<3;i++){...} 互不影响 若想循环体外还可以调用 for 循环体内的值，应先在体外定义。 如： int i; for (i=0; i<10; i++){...} 则for 循环后再调用 i 值，其值为10
关键字列表： abstract boolean break byte case catch char class continue default do double else extends enum false final finally float for if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient true try void volatile while Java 中 true、false不是关键字,而是boolean类型的字面量。但也不能当作变量用。 所有的关键字都是小写，friendly，sizeof不是java的关键字 保留字：const，goto ：这两个已经削去意义，但同样不能用作变量名。
随机数： Math.random(); //可以产生随机的0~1 的小数,不需导包 java.util.Random; //可以产生更加多种的随机数 0~100的一个随机整数(包括0，但不包括100)： Double d = 100*Math.random(); int r = d.intValue(); //方法一 Random r = new Random(); int num = r.nextInt(100); //方法二；需要 import java.util.Random; 可以直接在程序中写这句，而临时导入 int i = new java.util.Random().nextInt(100);
Arrays.sort(数组名) 排序算法。需导入 impor java.util.Arrays;
数组的拷贝: 1. 用 for 语句，将数组的元素逐个赋值。直接如果直接将数组 a = 数组b;则是将b的指针赋给a 2. 用System.arraycopy(); arraycopy(Object src, int srcPos, Object dest, int destPos, int length) src - 源数组。 srcPos - 源数组中的起始位置。 dest - 目标数组。 destPos - 目标数据中的起始位置。 length - 要复制的数组元素的数量。 如：System.arraycopy(a, 0, b, 0, a.length); //把数组 a 全部复制到数组 b 中
四、白箱复用和黑箱复用 1．白箱复用：又叫继承复用，子类会继承父类所有的东西， 从某种程度上说白箱复用破坏了封装。是一种 is a 的关系。 例：class Liucy{ public void teachCpp(){System.out.println("Teach Cpp");} public void chimogu(){ } } class Huxy extends Liucy{}
2、黑箱复用：又叫组合复用，是一种 has a 的关系。 例：class Liucy{ public void teachCpp(){System.out.println("Teach Cpp");} public void chimogu(){ } } class Huxy { private Liucy liucy = new Liucy(); public void teachCpp(){liucy.teachCpp();} } 原则：组合复用取代继承复用原则。 使我们可以有机会选择该复用的功能。
多态 1．定义：是指一个对象可以有多种形态，换句话说多态使我们可以把一个子类对象看作是一个父类对象类型 (例：father A = new child() )。 多态指的是编译时的类型变化，而运行时类型不变。 2．多态分为两种：编译时多态和运行时多态。 编译时类型：定义时类型(主观概念)把它看作什么。 运行时类型：真实类型(客观概念) 实际上他是什么。 重载是编译时多态，覆盖是运行时多态。在方法重载的情况下，参数类型决定于编译时类型。 3．作用：在需要一类对象的共性时，可以很容易的抽取。并且可以屏蔽不同子类对象之间所不关心的差异。 多态方便写出更通用的代码，以适应需求的不断变化 4．多态常见的用法： (1)、多态用在方法的参数上 (2)、多态用在方法的返回类型上 5．运行时多态的三原则： (1)、对象不变(改变的是主观认识) (2)、对于对象的调用只能限于编译时类型的方法。 (3)、在程序的运行时，动态类型判定。运行时调用运行时类型，即他调用覆盖后的方法。 注意：多态时，只有一般方法是动态调用的；而 static 方法和 final 方法依然是静态调用的；属性全是静态调用的。 如：father A = new child(); 则A的一般方法是child的方法；但A的属性是father的属性。 同样：child C = new child(); 则 (father)C 的一般方法还是child的方法，但属性是father的属性。
触发类加载的几种情况： (1)、调用静态成员时，会加载静态成员真正所在的类及其父类。 通过子类调用父类的静态成员时，只会加载父类而不会加载子类。 (2)、第一次 new 对象的时候 加载(第二次再 new 同一个类时，不需再加载)。 (3)、加载子类会先加载父类。 注：如果静态属性有 final 修饰时，则不会加载，当成常量使用。 例：public static final int a =123; 但是如果上面的等式右值改成表达式(且该表达式在编译时不能确定其值)时则会加载类。 例：public static final int a = math.PI 如果访问的是类的公开静态常量，那么如果编译器在编译的时候能确定这个常量的值，就不会被加载； 如果编译时不能确定其值的话，则运行时加载
/**********************************************************/ final class Season1{ //用 final 不让人继承 private Season1(){} //用 private 构造方法，不让人 new 出来 public static final Season1 SPRING=new Season1("春"); public static final Season1 SUMMER=new Season1("夏"); public static final Season1 AUTUMN=new Season1("秋"); public static final Season1 WINTER=new Season1("冬"); String name; //将"春夏秋冬"设为本类型，而不是24种基本类型，为防止值被更改 private Season1(String name){ this.name=name; } public String getName(){ return this.name; }} /********上面是以前版本时自定义的枚举，下面是新版的枚举写法********/ enum Season2{ SPRING("春"), SUMMER("夏"), AUTUMN("秋"), WINTER("冬"); String name; Season2(String name){ this.name=name; } public String getName(){return this.name;} }//注意：枚举类是有序的；如：Season2.SPRING.ordinal() /**********************************************************/ /*******关于枚举的例子****************************************/ import static java.lang.System.*; public class TestTeacher { public static void main(String[] args) { for(TarenaTeacher t:TarenaTeacher.values()){ t.teach(); }}} enum TarenaTeacher{ LIUCY("liuchunyang"){void teach(){out.println(name+" teach UC");}}, CHENZQ("chenzongquan"){void teach(){out.println(name+" teach C++");}}, HAIGE("wanghaige"){void teach(){out.println(name+" teach OOAD");}}; String name; TarenaTeacher(String name){this.name=name;} abstract void teach(); } /**********************************************************/ enum Animals { DOG ("WangWang") , CAT("meow") , FISH("burble"); String sound; Animals ( String s ) { sound = s; } } class TestEnum { static Animals a; public static void main ( String[] args ) { System.out.println ( a.DOG.sound + " " + a.FISH.sound ); }} /**********************************************************/
五、新型 for 循环 for—each，用于追求数组与集合的遍历方式统一 1、数组举例： int[] ss = {1,2,3,4,5,6}; for(int i=0; i System.out.print(ss[i]); } //以上是以前的 for 循环遍历，比较下面的for—each System.out.println(); for(int i : ss){ System.out.print(i); 2、集合举例： List ll = new ArrayList(); for(Object o : ll ){ System.out.println(o); } 注：凡是实现了java.lang.Iterable接口的类就能用 for—each遍历 用 for—each时，不能用list.remove()删除，因为他内部的迭代器无法调用，造成多线程出错。 这时只能用 for 配合迭代器使用。
六、泛型 Generic 1、为了解决类型安全的集合问题引入了泛型。 泛型是编译检查时的依据，也是编译期语法。 (编译期语法：编译期有效，编译后擦除，不存在于运行期) 2、简单的范型应用：集合(ArrayList, Set, Map, Iterator, Comparable) List l = new ArrayList(); :表示该集合中只能存放String类型对象。 3、使用了泛型技术的集合在编译时会有类型检查，不再需要强制类型转换。 String str = l.get(2); //因为List l, 所以 Error 注：一个集合所允许的类型就是这个泛型的类型或这个泛型的子类型。 4、List l = new ArrayList //Error List l = new ArrayList //Right 必须类型一致，泛型没有多态 5、泛型的通配符 泛型的通配符表示该集合可以存放任意类型的对象。但只有访问，不可以修改。 static void print( Cllection c ){ for( Object o : c ) out.println(o); } 6、带范围的泛型通配符 泛型的声明约定T表示类型，E表示元素 (1)、上界通配符，向下匹配： 表明“extends”或“implements”，认为是 final 的 表示该集合元素可以为Number类型及其子类型(包括接口)，例如 Number,Integer,Double 此时集合可以进行访问但不能修改。即不允许调用此对象的add,set等方法；但可以使用 for-each 或 get. (2)、下界通配符，向上匹配： 表示该集合元素可以为Number类型及其父类型，直至 Object。 可以使用 for-each,add,addAll,set,get等方法 (3)、接口实现： 表示该集合元素可以为实现了Comparable接口的类 7、泛型方法 在返回类型与修饰符之间可以定义一个泛型方法，令后面的泛型统一 这里只能用 extends 定义，不能用 super ；后面可以跟类(但只能有一个，且要放在首位)其余是接口 符号只有 & //“＆”表示“与”；逗号表示后面的另一部分 静态方法里面，不能使用类定义的泛型，只能用自己定义的；因为静态方法可以直接调用； 所以普通方法可以使用类定义的及自己定义的泛型 public static void copy(T[] array,Stack sta){……} public static void copy (T[] array,Stack sta){…..} public static void copy(List list,T[] t); 8、不能使用泛型的情况： (1)、带泛型的类不能成为 Throwable 类和 Exception 类的子类 因为cathc()中不能出现泛型。 (2)、不能用泛型来 new 一个对象 如：T t = new T(); (3)、静态方法不能使用类的泛型，因为静态方法中没有对象的概念。 9、在使用接口的时候指明泛型。 class Student implements Comparable{…….}
10、泛型类 /********************************************************************/ class MyClass{ public void m1(T t){} public T m2(){ return null; }} /********************************************************************/
第九章： 内部类(nested classes) (非重点) 1．定义：定义在其他类中的类，叫内部类(内置类)。内部类是一种编译时的语法,编译后生成 的两个类是独立的两个类。内部类配合接口使用,来强制做到弱耦合(局部内部类，或私有成员内部类)。 2．内部类存在的意义在于可以自由的访问外部类的任何成员(包括私有成员),但外部类不能直接访问内部类的 成员。所有使用内部类的地方都可以不使用内部类;使用内部类可以使程序更加的简洁(但牺牲可读性), 便于命名规范和划分层次结构。 3．内部类和外部类在编译时是不同的两个类，内部类对外部类没有任何依赖。 4．内部类可用 static,protected 和 private 修饰。(而外部类只能使用 public 和 default)。 5．内部类的分类：成员内部类、局部内部类、静态内部类、匿名内部类。 (注意：前三种内部类与变量类似，可以对照参考变量) ① 成员内部类(实例内部类)：作为外部类的一个成员存在，与外部类的属性、方法并列。 成员内部类可看作外部类的实例变量。 在内部类中访问实例变量：this.属性 在内部类访问外部类的实例变量：外部类名.this.属性。 对于一个名为outer 的外部类和其内部定义的名为inner 的内部类。 编译完成后出现outer.class 和outer$inner.class 两类。 不可以有静态属性和方法(final 的除外),因为 static 在加载类的时候创建,这时内部类还没被创建 如果在外部类的外部访问内部类，使用out.inner.*** 建立内部类对象时应注意： 在创建成员内部类的实例时，外部类的实例必须存在： 在外部类的内部可以直接使用inner s=new inner(); 因为外部类知道 inner 是哪个类。 而在外部类的外部，要生成一个内部类对象，需要通过外部类对象生成。 Outer.Inner in = new Outer().new Inner(); 相当于：Outer out = new Outer(); Outer.Inner in = out.new Inner(); 错误的定义方式：Outer.Inner in=new Outer.Inner()。 ② 局部内部类：在方法中定义的内部类称为局部内部类。 类似局部变量，不可加修饰符 public、protected 和 private，其范围为定义它的代码块。 可以访问外部类的所有成员，此外，还可以访问所在方法中的 final 类型的参数和变量。 在类外不可直接生成局部内部类(保证局部内部类对外是不可见的)。 要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。 局部内部类不能声明接口和枚举。 ③ 静态内部类：(也叫嵌套类) 静态内部类定义在类中，在任何方法外，用 static 定义。 静态内部类能直接访问外部类的静态成员； 不能直接访问外部类的实例成员,但可通过外部类的实例(new 对象)来访问。 静态内部类里面可以定义静态成员(其他内部类不可以)。 生成(new)一个静态内部类不需要外部类成员，这是静态内部类和成员内部类的区别。 静态内部类的对象可以直接生成： Outer.Inner in=new Outer.Inner()； 对比成员内部类：Outer.Inner in = Outer.new Inner(); 而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。 静态内部类不可用 private 来进行定义。例子： 对于两个类，拥有相同的方法： /*************************************************************************/ /*class People{void run();} interface Machine{void run();} 此时有一个robot类： class Robot extends People implement Machine. 此时run()不可直接实现。*/ interface Machine{ void run();} class Person{ void run(){System.out.println("run");}}
class Robot extends Person{ private class MachineHeart implements Machine{ public void run(){System.out.println("heart run");} } public void run(){System.out.println("Robot run");} Machine getMachine(){return new MachineHeart();} }
匿名内部类的例子： /*************************************************************************/ public class test{ public static void main(String[] args){ B.print(new A(){ public void getConnection(){ System.out.println("Connection....");} }); }}
interface A{ void getConnection();} class B{ public static void print(A a){ a.getConnection();} } /*************************************************************************/
下面是用反射调用私有方法的一个例子: /**********************************************************/ public class TestClass2 { public static void main(String[] args) throws Exception{ System.out.println("请输入需要读取的类名："); Scanner scanner = new Scanner(System.in); String str = scanner.next(); //输入“AA” Class c = Class.forName(str); Method[] m = c.getDeclaredMethods();//读取它的全部方法 Method m1 = m[0];//拿其中的第一个方法 m1.setAccessible(true);//把private的属性设成可访问，否则不能访问 AA b = new AA(); m1.invoke(b); }}
使用注释 /*********************************************/ Class c = Class.forName(args[0]); Object o = c.newInstance(); Method[] ms = c.getMethods(); for(Method m:ms){ //判断m方法上有没有Test注释 if (m.isAnnotationPresent(Test.class)){ //得到m之上Test注释parameter属性值 Test t=m.getAnnotation(Test.class); String parameter=t.parameter(); m.invoke(o,parameter); }} /*********************************************/
五、网络套节字Socket(TCP) 1、一个Socket相当于一个电话机。 OutputStream相当于话筒 InputStream相当于听筒 2、服务器端要创建的对象：java。Net。ServerSocket 3、创建一个TCP服务器端程序的步骤： 1). 创建一个ServerSocket 2). 从ServerSocket接受客户连接请求 3). 创建一个服务线程处理新的连接 4). 在服务线程中，从socket中获得I/O流 5). 对I/O流进行读写操作，完成与客户的交互 6). 关闭I/O流 7). 关闭Socket /***********************************************************/ import java.net.*; import java.io.*; public class TcpServer{//服务器端 public static void main(String[] args) { ServerSocket ss = null; Socket s = null; try{ ss= new ServerSocket(10222); s = ss.accept();//客户端连上后返回Socket，监听端口 OutputStream os = s.getOutputStream(); PrintWriter pw = new PrintWriter(os); pw.println("欢迎欢迎！");//要换行，否则不能读取 pw.flush();//从内存输出去 }catch(Exception e){} finally{if(s!=null )try{s.close(); }catch(Exception e){} if(ss!=null)try{ss.close();}catch(Exception e){} }}}
public class TcpClient {//接受端 public static void main(String[] args) throws Exception { Socket s = new Socket("10.3.1.79", 10222); BufferedReader br = new BufferedReader(new InputStreamReader (s.getInputStream())); System.out.println(br.readLine()); s.close(); }} /***********************************************************/
Usage: java [-options] class [args...] (to execute a class) or java [-options] -jar jarfile [args...] (to execute a jar file)
where options include: -d32 use a 32-bit data model if available -d64 use a 64-bit data model if available -client to select the "client" VM -server to select the "server" VM -hotspot is a synonym for the "client" VM [deprecated] The default VM is client. -cp -classpath A : separated list of directories, JAR archives, and ZIP archives to search for class files. -D= set a system property -verbose[:class|gc|jni] enable verbose output -version print product version and exit -version: require the specified version to run -showversion print product version and continue -jre-restrict-search | -jre-no-restrict-search include/exclude user private JREs in the version search -? -help print this help message -X print help on non-standard options -ea[:...|:] -enableassertions[:...|:] enable assertions -da[:...|:] -disableassertions[:...|:] disable assertions -esa | -enablesystemassertions enable system assertions -dsa | -disablesystemassertions disable system assertions -agentlib:[=] load native agent library , e.g. -agentlib:hprof see also, -agentlib:jdwp=help and -agentlib:hprof=help -agentpath:[=] load native agent library by full pathname -javaagent:[=] load Java programming language agent, see java.lang.instrument -splash: show splash screen with specified image
import java.util.Scanner; class Bissextile{ public static void main(String[] arge){ System.out.print("请输入年份"); int year; //定义输入的年份名字为“year” Scanner scanner = new Scanner(System.in); year = scanner.nextInt(); if (year<0||year>3000){ System.out.println("年份有误，程序退出！"); System.exit(0); } if ((year%4==0)&&(year%100!=0)||(year%400==0)) System.out.println(year+" is bissextile"); else System.out.println(year+" is not bissextile "); } }
import java.util.Scanner; class Mark{ public static void main(String[] args){ System.out.println("请输入一个分数"); //定义输入的分数为“mark”，且分数会有小数 double mark; Scanner scanner = new Scanner(System.in); mark = scanner.nextDouble();
//判断是否有输入错误。 if(mark<0||mark>100){ System.out.println("输入有误！ "); System.exit(0); } /*判断分数的等级 90分以上者A级， 80~89分者 B级，70~79分者 C级， 60~69者 D级，60分以下 E级 */ if (mark>=90) System.out.println("this mark is grade /'A/' "); else if (mark>=80) System.out.println("this mark is grade /'B/' "); else if (mark>=70) System.out.println("this mark is grade /'C/' "); else if (mark>=60) System.out.println("this mark is grade /'D/' "); else System.out.println("this mark is grade /'E/' "); } }
3，编写程序求 1+3+5+7+……+99 的和值。
class he{ public static void main(String[] args){ int number = 1; //初始值1，以后再+2递增上去 int sum = 0; for ( ; number <100; number+=2 ){ sum += number; } System.out.println("1+3+5+7+……+99= " +sum); } }
class DafodilNumber{ public static void main(String[] args){ System.out.println("以下是所有的水仙花数"); int number = 100; // 由于水仙花数是三位数，故由100开始算起
int i, j, k; // i j k 分别为number 的百位、十位、个位 for (int sum; number<1000; number++){ i=number/100; j=(number-i*100)/10; k=number-i*100-j*10; sum=i*i*i+j*j*j+k*k*k; if (sum==number) System.out.println(number+" is a dafodil number! "); } } }
import java.util.Scanner; class Multinomial{ public static void main(String[] args){ int a; //定义输入的 a int howMany; //定义最后的一项有多少个数字 Scanner scanner = new Scanner(System.in); System.out.println("请输入一个 1~9 的 a 值"); a = scanner.nextInt(); System.out.println("请问要相加多少项？"); howMany = scanner.nextInt(); int sum=0; int a1=a; // 用来保存 a 的初始值 for (int i=1; i<=howMany; i++){ sum+= a; a = 10*a +a1; // 这表示a 的下一项 // 每次 a 的下一项都等于前一项*10，再加上刚输入时的 a ；注意，这时的 a 已经变化了。 } System.out.println("sum="+sum); } }
class Pi { public static void main(String[] args){ double pi =0; //定义初始值 double fenZi = 4; //分子为4 double fenMu = 1; //第一个4，可看作分母为1 的分式，以后的分母每次递增2 for (int i = 0; i < 1000000000; i++){ //运行老久，减少循环次数会快很多，只是精确度小些 pi += (fenZi/fenMu) ; fenZi *= -1.0; //每项分子的变化是+4，－4，+4，－4 .... fenMu += 2.0; //分母的变化是1，3，5，7， .... 每项递加2 } System.out.println(pi); } } 输出结果为pi = 3.1415926525880504，应该不精确
12、输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值 1 1 2 3 5 8 13 21 34 规律：一个数等于前两个数之和 //计算斐波那契数列(Fibonacci)的第n个值 public class Fibonacci{ public static void main(String args[]){ int n = Integer.parseInt(args[0]); int n1 = 1;//第一个数 int n2 = 1;//第二个数 int sum = 0;//和 if(n<=0){ System.out.println("参数错误!"); return; } if(n<=2){ sum = 1; }else{ for(int i=3;i<=n;i++){ sum = n1+n2; n1 = n2; n2 = sum; } } System.out.println(sum); } }
//计算斐波那契数列(Fibonacci)的第n个值 //并把整个数列打印出来 public class FibonacciPrint{ public static void main(String args[]){ int n = Integer.parseInt(args[0]); FibonacciPrint t = new FibonacciPrint(); for(int i=1;i<=n;i++){ t.print(i); } } public void print(int n){ int n1 = 1;//第一个数 int n2 = 1;//第二个数 int sum = 0;//和 if(n<=0){ System.out.println("参数错误!"); return; } if(n<=2){ sum = 1; }else{ for(int i=3;i<=n;i++){ sum = n1+n2; n1 = n2; n2 = sum; } } System.out.println(sum); } }
class ArrayNumber{ public static void main(String[] args){ int[] arrayNumber; arrayNumber = new int[10]; System.out.println("以下是随机的10个整数："); // 填入随机的 10个整数 for (int i =0; i arrayNumber[i] = (int)(100*Math.random()); System.out.print(arrayNumber[i]+" "); } System.out.println(); int max = arrayNumber[0]; int min = arrayNumber[0]; int sum = 0; for (int i =0; i if(max < arrayNumber[i]) max = arrayNumber[i]; //求最大值 if(min > arrayNumber[i]) min = arrayNumber[i]; //求最小值 sum += arrayNumber[i]; } System.out.println("其中 Max="+max+",Min="+min+",Sum="+sum+",Avg="+sum/10.0); } }
class Remain{ public static void main( String[] args){ int[] a = new int[100];
//保存100个随机4位数到 a 中 for (int i = 0; i < a.length; i++){ a[i] = (int) (1000*Math.random()); }
//统计 a 数组中的元素对 10 求余的各个的数目 int[] b = new int[10]; int k,sum; for (int j = 0; j < b.length; j++){ for (k=0,sum=0; k < a.length; k++){ if ((a[k]%10)==j) sum++; } b[j] = sum; System.out.printf("b[%d]=%d/n",j,b[j]); } } }
个人认为，可以先把最中间的数填到九宫格的最中间位置；再按上面的规则逐个填写，而且 填的时候还可以把头尾对应的数填到对应的格子中。(第 n 个值跟倒数第 n 个值对应，格局上以最中 间格为轴心对应) 这样就可以同时填两个数，效率比之前更高；其正确性有待数学论证(但多次实验之后都没发现有错)。 九宫格的 1 至少还可以填在另外的三个位置，只是接下来的填写顺序需要相应改变； 再根据九宫格的对称性，至少可以有8种不同的填写方式
import java.util.Scanner; class NinePalace{ public static void main(String[] args){ // 定义 N 为九宫格的行列数，需要输入 System.out.println("请输入九宫格的行列规模(只能是奇数的)"); Scanner n = new Scanner(System.in); int N;
//判断格局是否奇数 （可判断出偶数、负数 及小数） double d; while (true){ d = n.nextDouble(); N = (int)d; if ((d-N)>1.0E-4||N%2==0||N<0) {System.out.println("输入出错,格局只能是正奇数。请重新输入");} else break; }
//老师的九宫格填写方法 int[][] result = new int[N][N]; //定义保存九宫格的数组 int row = 0; //行 初始位置 int col = N/2; //列 初始位置,因为列由0开始，故N/2是中间位置 for (int i=1; i<=N*N; i++){ result [row][col] = i; row--; col++; if (row<0&&col>=N){col--;row+=2;} //行列都越界 else if (row<0){ row = N-1;} //行越界 else if (col>=N){col = 0;} //列越界 else if (result[row][col] != 0){col--;row+=2;} //有冲突 }
//打印出九宫格 for (int i=0; i for(int j=0; j System.out.println(); }
//我个人的填格方式 int[][] result2 = new int[N][N]; //为免冲突，重新 new 一个数组 result2[N/2][N/2] = (N*N+1)/2; //先把中间值赋予中间位置 row = 0; //定义行及列的初始赋值位置。之前赋值的for对两个值有影响，故需重新定位 col = N/2; for (int i=1; i<=N*N/2; i++){ result2[row][col] = i; //下面这句是把跟 i 对应的值放到格局对应的位置上 result2[N-row-1][N-col-1] = N*N+1-i; row--; col++; if (row<0){ row = N-1;} //行越界 else if (col>=N){col = 0;} //列越界 else if (result2[row][col] != 0){col--;row+=2;} //有冲突 //这方法不可能出现行列两边都越界的情况,详情需要数学论证 }
System.out.println(); //再次打印出九宫格，以对比验证 for (int i=0; i for(int j=0; j System.out.println(); }
public class TestEmployee{ public static void main(String[]args){ Employee[] es = new Employee[5]; es[0] = new Employee("赵君",2); es[1] = new SalariedEmployee("宋婕", 1, 8000); es[2] = new HourlyEmployee("王超", 5, 10, 300); es[3] = new SalesEmployee("秋娥", 2, 200000, 0.05); es[4] = new BaseSalarySalesEmployee("郭镫鸿", 1, 1000000, 0.1, 10000); int month = 2;//本月为2月 System.out.println("宇宙集团"+month+"月工资表："); for(int i=0; i System.out.println(es[i].getName()+":"+es[i].getSalary(month)); } } }
class Employee{ private String name; private int birth; public String getName(){ return name; } public Employee(String name, int birth){ this.name = name; this.birth = birth; } public double getSalary(int month){ if(month==birth){ return 100; } return 0; } }
class SalariedEmployee extends Employee{ private double salary; public SalariedEmployee(String name, int birth, double salary){ super(name, birth); this.salary = salary; } public double getSalary(int month){ return salary + super.getSalary(month); } }
class HourlyEmployee extends Employee{ private double hourSalary; private int hour; public HourlyEmployee(String name, int birth, double hourSalary, int hour){ super(name, birth); this.hourSalary = hourSalary; this.hour = hour; } public double getSalary(int month){ if(hour<=160){ return hourSalary*hour+super.getSalary(month); }else{ return 160*hourSalary+(hour-160)*hourSalary*1.5+super.getSalary(month); } } }
class SalesEmployee extends Employee{ private double sales; private double pre; public SalesEmployee(String name, int birth, double sales, double pre){ super(name, birth); this.sales = sales; this.pre = pre; } public double getSalary(int month){ return sales*pre+super.getSalary(month); } }
class BaseSalarySalesEmployee extends SalesEmployee{ private double baseSalary; public BaseSalarySalesEmployee(String name, int birth, double sales, double pre, double baseSalary){ super(name, birth, sales, pre); this.baseSalary = baseSalary; } public double getSalary(int month){ return baseSalary+super.getSalary(month); } }
/** * 在原有的雇员练习上修改代码 * 公司会给SalaryEmployee每月另外发放2000元加班费,给 * BasePlusSalesEmployee发放1000元加班费 * 改写原有代码,加入以上的逻辑 * 并写一个方法,打印出本月公司总共发放了多少加班费 * @author Administrator * */ public class EmployeeTest {
/** * @param args */ public static void main(String[] args) { Employee e[] = new Employee[4]; e[0] = new SalariedEmployee("魏威",10,5000); e[1] = new HourlyEmployee("段利峰",8,80,242); e[2] = new SalesEmployee("林龙",11,300000,0.1); e[3] = new BasedPlusSalesEmployee("华溪",1,100000,0.15,1500); for(int i=0;i System.out.println(e[i].getName()+": "+e[i].getSalary(11)); }
//统计加班费 int result = 0; // for(int i=0;i// if(e[i] instanceof SalariedEmployee){ // SalariedEmployee s = (SalariedEmployee)e[i]; // result += s.getAddtionalSalary(); // } // if(e[i] instanceof BasedPlusSalesEmployee){ // BasedPlusSalesEmployee b = (BasedPlusSalesEmployee)e[i]; // result += b.getAddtionalSalary(); // } // }
for(int i=0;i result += e[i].getAddtionalSalary(); } System.out.println("加班费: "+result); } }
interface AddtionalSalary{ int getAddtionalSalary(); }
class Employee implements AddtionalSalary{ private String name;//员工姓名 private int birth;//员工生日月份 public Employee(String name,int birth){ this.name = name; this.birth = birth; } public int getSalary(int month){ int result = 0; if(month==birth) result = 100; return result; } public String getName(){ return name; }
public int getAddtionalSalary(){ return 0; } }
class SalariedEmployee extends Employee{ private int salaryPerMonth; public SalariedEmployee(String name,int birth,int salaryPerMonth){ super(name,birth); this.salaryPerMonth = salaryPerMonth; } public int getSalary(int month){ return this.salaryPerMonth + super.getSalary(month)+ this.getAddtionalSalary(); } public int getAddtionalSalary(){ return 2000; } }
class HourlyEmployee extends Employee{ private int salaryPerHour; private int hoursPerMonth; public HourlyEmployee(String name,int birth,int salaryPerHour,int hoursPerMonth){ super(name,birth); this.salaryPerHour = salaryPerHour; this.hoursPerMonth = hoursPerMonth; } public int getSalary(int month){ int result = 0; if(this.hoursPerMonth<=160){ result = hoursPerMonth*salaryPerHour; }else{ result = 160*salaryPerHour + (int)((hoursPerMonth-160)*1.5*salaryPerHour); } return result+super.getSalary(month); } }
class SalesEmployee extends Employee{ private int sales; private double rate; public SalesEmployee(String name,int birth,int sales,double rate){ super(name,birth); this.sales = sales; this.rate = rate; } public int getSalary(int month){ return (int)(sales*rate)+super.getSalary(month); } }
class BasedPlusSalesEmployee extends SalesEmployee{ private int basedSalary; public BasedPlusSalesEmployee(String name,int birth,int sales,double rate,int basedSalary){ super(name,birth,sales,rate); this.basedSalary = basedSalary; } public int getSalary(int month){ return this.basedSalary+super.getSalary(month) + this.getAddtionalSalary(); } public int getAddtionalSalary(){ return 1000; } }
2. 让数值在 0～9 之间循环。 public class test{ public static void main(String[] args){ int i=0; while(true){ i = (i+1)%10; System.out.println(i); } } }
作业： 1. 写一个数组类（放对象）： 功能包括：添加(添加不限制多少项)、修改、插入、删除、查询 class MyArray{ private Object[] os = new Object[10]; public void add(Object o); public void set(int index, Object o); public void insert(int index, Objecto); public void remove(int index); public void remove(Object o); public Object get(int index);
}
public class TestMyArray{ public static void main(String[]args){ MyArray ma = new MyArray(); ma.add("aaa"); ma.add("bbb"); ma.add("ccc"); Object o = ma.get(1); Iterator it = ma.iterator(); while(it.hasNext()){ Object o1 = it.next(); System.out.println(o1); } } }
import java.util.*; class Teacher{ int id; String name; int age; public Teacher() {} public Teacher(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) {this.id = id; } public String getName() { return name;} public void setName(String name) { this.name = name;} public int getAge() {return age;} public void setAge(int age) {this.age = age;}
public int TeacherComparator(Object o){ Teacher t1 = (Teacher) o; if(t1.getId() > id){return 1;} else if (t1.getId() < id){return -1;} return 0; } } class TreeSet{
}
class Test { public static void main(String[] args) { String s1 = new String("aaa"); String s2 = new String("bbb"); String s3 = new String("aaa"); System.out.println(s1==s3); System.out.println(s1.equals(s3));
HashSet hs = new HashSet(); hs.add(s1); hs.add(s2); hs.add(s3); Iterator it = hs.iterator(); while(it.hasNext()){ System.out.println(it.next()); } System.out.printf("%x/n",s1.hashCode()); System.out.printf("%x/n",s2.hashCode()); System.out.printf("%x/n",s3.hashCode()); } }
1. 在Map中，以name作Key，以Student类 作Velue，写一个HashMap import java.util.*; class Student{ int id; String name; int age; public Student() {} public Student( int id, String name, int age) { this.id = id; this.name = name; this.age = age; } public int getId() {return id;} public void setId(int id) {this.id = id;} public String getName() {return name;} public void setName(String name) {this.name = name;} public int getAge() {return age;} public void setAge(int age) {this.age = age;} }
class TestHashMap{ public static void main(String[] args) { HashMap hm = new HashMap(); Student s1 = new Student(1,"jacky",19); hm.put("jacky",s1); hm.put("tom",new Student(2,"tom",21)); hm.put("kitty",new Student(3,"kitty",17));
Iterator it = hm.keySet().iterator(); while(it.hasNext()){ Object key = it.next(); Student value = (Student) hm.get(key); System.out.println(key+":id="+value.id+",age="+value.age); } System.out.println("=============================");
class Calculator { public static void main(String[] args){ JTextField text = new JTextField(); JFrame f = new JFrame("计算器"); Font font = new Font("宋体", Font.BOLD, 25);//"宋体"想写成默认，则写“null” text.setFont(font); //定义字体 text.setHorizontalAlignment(JTextField.RIGHT);//令text的文字从右边起 text.setEditable(false);//设置文本不可修改，默认可修改(true) f.add(text, BorderLayout.NORTH);//Frame和Dialog的默认布局管理器是Border Layout ButtonActionListener listener = new ButtonActionListener(text);//事件反应在text中 JPanel buttonPanel = new JPanel();//设法把计算器键盘放到这个Jpanel按钮上 String op = "123+456-789*0.=/"; GridLayout gridlayout = new GridLayout(4,4,10,10); buttonPanel.setLayout(gridlayout);//把计算器键盘放到buttonPanel按钮上 for(int i=0; i char c = op.charAt(i); //拿到字符串的第i个字符 JButton b = new JButton(c+"");//把字符放到按钮上 b.addActionListener(listener);//在按钮上放置监听器，每次按都会有反应 buttonPanel.add(b);//把按钮放到buttonPanel上 }//这个循环很值得学习，很常用 f.add(buttonPanel/*, BorderLayout.CENTER*/); //默认添加到CENTER位置 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); f.setSize(300, 250); f.setVisible(true);//这句要放到最后，等事件完成后再显示 }}
//监听者 class ButtonActionListener implements ActionListener{ private JTextField textField; public ButtonActionListener(JTextField textField) { this.textField = textField; } public void actionPerformed(ActionEvent e) {//必须覆盖它的actionPerformed()
CVS commands are: add Add a new file/directory to the repository admin Administration front end for rcs annotate Show last revision where each line was modified checkout Checkout sources for editing commit Check files into the repository提交 diff Show differences between revisions查看两版本间的差异。 用法：diff 版本1 版本2 分左右两页显示：diff side-by-side 版本1 版本2 edit Get ready to edit a watched file editors See who is editing a watched file export Export sources from CVS, similar to checkout history Show repository access history import Import sources into CVS, using vendor branches init Create a CVS repository if it doesn't exist log Print out history information for files login Prompt for password for authenticating server logout Removes entry in .cvspass for remote repository pserver Password server mode rannotate Show last revision where each line of module was modified rdiff Create 'patch' format diffs between releases release Indicate that a Module is no longer in use remove Remove an entry from the repository rlog Print out history information for a module rtag Add a symbolic tag to a module server Server mode status Display status information on checked out files tag Add a symbolic tag to checked out version of files unedit Undo an edit command update Bring work tree in sync with repository version Show current CVS version(s) watch Set watches watchers See who is watching a file (Specify the --help option for a list of other help options)
J2ee | 评论:0 | Trackbacks:0 | 阅读:65
03. PL SQL笔记
Submitted by cnetsa on 2009, July 29, 2:19 PM
大小写不敏感。
打印单引号时，需加多一个单引号作转义符。即连用两个单引号才可以打印一个。 Begin dbms_output.put_line('I''m leaning'); End;
程序执行顺序的类型可分三种： 顺序 选择 If ... Then ... Elsif ... Then ... Else ... End If; 循环 一、LOOP循环： 1. Loop ... ; Exit When boolean_expr ; End Loop; 2. Loop If boolean_expr Then Exit; End If; ...; End Loop;
二、While循环： While boolean_expression Loop ... End Loop; 其中boolean_expression 值为False则立即退出循环。免另外写结束条件。 可以使用Exit或Exit When 语句终止循环处理。
三、For循环： For loop_count IN [Reverse] low_bound..high_bound Loop ...; End Loop; 免声明，默认loop_count为数值型。简化结束条件。 IN Reverse 表示倒过来，由大值自减到小值 例： For cnt IN 1..5 Loop ...; End Loop; /*由1到5*/
MySQL 常用语句： 终端登录： mysql -u username -p password --进入本机的mysql；没设密码就留空 执行脚本： mysql -u 用户名 -密码 执行脚本2：先登录，再 source /.../xxx.sql show variables like '%char%'; --查看数据库的字符集；utf8或gbk的则可支持中文 show databases; --显示所有数据库目录 use 数据库名; --进入某个数据库 (可以有很多个，我把这些数据库看作目录，这点不同于oracle) show tables; --显示此目录下各表格的名字 desc 表名; --我们可以查看某个表中的数据类型结构 create database 数据库名; --建数据库目录 drop database 数据库名; --删除数据库整个目录 create table 表名; --建表(同oracle) drop table 表名; --连删表(删多个表用逗号隔开)
Note that all text commands must be first on line and end with ';' ? (/?) Synonym for 'help'. clear (/c) Clear command. connect (/r) Reconnect to the server. Optional arguments are db and host. delimiter (/d) Set statement delimiter. NOTE: Takes the rest of the line as new delimiter. edit (/e) Edit command with $EDITOR. ego (/G) Send command to mysql server, display result vertically. exit (/q) Exit mysql. Same as quit. go (/g) Send command to mysql server. help (/h) Display this help. nopager (/n) Disable pager, print to stdout. notee (/t) Donot write into outfile. pager (/P) Set PAGER [to_pager]. Print the query results via PAGER. print (/p) Print current command. prompt (/R) Change your mysql prompt. quit (/q) Quit mysql. rehash (/#) Rebuild completion hash. source (/.) Execute an SQL script file. Takes a file name as an argument. status (/s) Get status information from the server. system (/!) Execute a system shell command. tee (/T) Set outfile [to_outfile]. Append everything into given outfile. use (/u) Use another database. Takes database name as argument. charset (/C) Switch to another charset. Might be needed for processing binlog with multi-byte charsets. warnings (/W) Show warnings after every statement. nowarning (/w) Donot show warnings after every statement.
二、写子句顺序 Select column,group_function From table [Where condition] [Group by group_by_expression] [Having group_condition] …… [Order by column]; --最后
三、常用简单语句： clear screen：清屏 edit：编辑刚才的一句。 desc/describe：(列出所有列名称) 用法： DESCRIBE [schema.]object[@db_link] dual：亚表，临时用。如：desc dual；／from dual； rollback：回溯，回溯到上次操作前的状态，把这次事务操作作废，只有一次(DDL和DCL语句会自动提交，不能回溯)。 可以用commit语句提交，这样就回溯不回了。 set pause on/off ：设置分屏(设置不分屏) set pause "please put an enter key" 且 set pause on：设置带有提示的分屏 oerr ora 904 ：查看错误 set head off ：去掉表头 set feed off ：去掉表尾 保存在oracle数据库中的所有操作细节： spool oracleday01.txt ：开始记录 spool off ：开始保存细节
四、SELECT语句：选择操作、投影操作。 select：从一个或多个表中检索一个或多个数据列。包含信息：想选择什么表，从什么地方选择。必须要有From子句。(最常用) 当从多张表里查询的时候，会产生笛卡尔积；可用条件过滤它。 当两个表有相同字段时必须加前缀，列名前需加表名和“.”，如“s_emp.id”。 1、用法：SELECT columns,prod2,prod3<列> FROM Table1,table2<表名> 分号结束 如： select id from s_emp; select last_name,name from s_emp,s_dept where s_emp.dept_id=s_dept.id;--列表每人所在部门 SELECT * FROM Products; --检索所有列。 数据太多时，最好别使用上句，会使DBMS降低检索和应用程序的性能。(*通配符) 2、对数据类型的列可进行运算(如加减乘除)。 3、对列起别名：有直接起别名，加AS起别名，用双引号起别名等三种方法 (单引号，引起字符串；双引号，引起别名。起别名有符号，或者区分大小写时，必须用双引号) 多表查询时，可给表起别名。(给列起别名，列<空格>列别名；给表起别名，表<空格>表别名；)。 如：Select first_name EMPLOYEES, 12*(salary+100) AS MONEY, manager_id "ID1" From s_emp E; 4、字段的拼接,可用双竖线(双竖线只能用于select语句里)。不同的DBMS可能使用不同的操作符;拼接的字段同样可以起别名。 如：Select first_name ||' '|| last_name || ', '|| title "Employees" From s_emp;
排他锁：Select id,salary From s_emp where id=1 For Update; 可以阻止他人并发的修改，直到你解锁。 如果已有锁则自动退出：Select id,salary From s_emp where id=1 For Update NoWait; FOR UPDATE ：可以再加 OF 精确到某格。如： ... For Update OF salary ... 注意要解锁。
五、ORDER BY 子句，排序 Order by：按某排序列表(默认升序 asc，由低到高；可加 desc，改成降序由高到低) 检索返回数据的顺序没有特殊意义，为了明确地排序用 SELECT 语句检索出的数据，可使用 ORDER BY 子句。 ORDER BY 子句取一个或多个列的名字。 对空值，按无穷大处理(升序中，空值排最后；降序中排最前)。 1、用法：Select prod_id,prod_price,prod_name From Products Order By prod_price,prod_name; (从左到右执行排序，先排price) ORDER BY子句中使用的列将是为显示所选择的列，但是实际上并不一定要这样，用非检索的列排序数据是完全合法的。 为了按多个列排序，列名之间用逗号分开。 2、支持按相对列位置进行排序。 输入 SELECT prod_id,prod_price,prod_name FROM Products ORDER BY 2，3 --(2指price，3指name) 3、升序、降序。默认是升序(asc，从小到大排序)，想降序时用desc。 如：SELECT prod_id,prod_price,prod_name FROM Products ORDER BY prod_price DESC; 注意：DESC 关键字只应用到直接位于其前面的列名。如果想在多个列上进行排序，必须对每个列指定DESC关键字。 升序是默认的，可不写，但降序必须写。
六、WHERE子句，选择、过滤 其后只能跟逻辑语句，返回值只有ture或false 如： select last_name,salary from s_emp where salary＝1000;--找出工资1000的人
2、SQL 比较运算符 between…and… ：在两者之间。(BETWEEN 小值 AND 大值) 如：select last_name,salary from s_emp where salary between 1000 and 1500； --工资1000到1500的人，包括1000和1500。 in(列表)：在列表里面的。 如：select last_name,dept_id from s_emp where dept_id in(41,42);第41、42部门的人 like ： 包含某内容的。模糊查询 可以利用通配符创建比较特定数据的搜索模式，通配符只能用于文本，非文本数据类型不能使用通配符。 通配符在搜索模式中任意位置使用，并且可以使用多个通配符。 通配符%表示任何字符出现任意次数；还能代表搜索模式中给定位置的0个或多个字符。下划线匹配单个任意字符。 如：select table_name from user_tables where table_name like 'S/_%' escape'/'; ' 找出“S_“开头的,由于下划线有任意字符的含义，故需另外定义转移符。 但习惯用“/”，为方便其他程序员阅读和检测，一般不改用其他的。 like 'M%'：M开头的 like '_a%'：第二个字符是a的 like '%a%'所有含a的 (“_”表示一个任意字符；“%”表示任意多个任意字符。) 单引号里面的内容，大小写敏感。单引号用来限定字符串， 如果将值与串类型的列进行比较，则需要限定引号；用来与数值列进行比较时，不用引号。 is null：是空。(NULL表示不包含值。与空格、0是不同的。) 如：SELECT prod_name,prod_price FROM Products WHERE prod_price IS NULL;
and：条件与 如 SELECT prod_id,prod_price,prod_name FROM Products WHERE prod_price<4 AND vend_id=‘DELL’ or：条件或 (注： and 的优先级比 or 更高，改变优先级可用括号) 如 SELECT prod_id,prod_price,prod_name FROM Products WHERE prod_price<4 OR vend_id=‘DELL’ not：条件非。否定它之后所跟的任何条件 否定的SQL 比较运算符： NOT BETWEEN； NOT IN； NOT LIKE； IS NOT NULL： (注意，按英语习惯用 is not，而不是 not is) NOT 与 IN 在一起使用时，NOT 是找出与条件列表不匹配的行。 IN 列表里有 NULL 时不处理，不影响结果；用 NOT IN 时，有 NULL 则出错，必须排除空值再运算。 in ：选择列表的条件 使用IN操作符的优点： 在长的选项清单时,语法直观； 计算的次序容易管理； 比 OR 操作符清单执行更快；最大优点是可以包含其他 SELECT 语句，使用能够动态地建立 WHERE 子句。 如 SELECT prod_id,prod_price,prod_name FROM Products WHERE vend_id IN(‘DELL’,’RBER’,’TTSR’);
Null：空值 空值当成无穷大处理，所有空值参与的运算皆为空。 空值与空值并不相等，因为空值不能直接运算。 如：prod_price="" 这种写法是错的(不要受到corejava的影响) prod_price=NULL 这种写法是错的(不要受到corejava的影响) prod_price IS NULL 这种写法才是对的 NVL：处理空值，把空值转化为指定值。可转化为日期、字符、数值等三种(注意：转化时，两参数必须要同类型) 如：NVL(date, '01-JAN-95') NVL(title,'NO Title Yet') NVL(salary,0) 错误写法： Select last_name,title,salary*commission_pct/100 COMM From s_emp;--没提成的人没法显示工资 正确写法： Select last_name,title,salary*NVL(commission_pct,0)/100 COMM From s_emp;--把提成是空值的转化为0
DISTINCT：过滤重复 把重复的行过滤掉；多个字段组合时，只排除组合重复的。 DISTINCT必须使用列名，不能使用计算或者表达式。 所有的聚合函数都可以使用。如果指定列名，则DISTINCT只能用于COUNT(列名)，DISTINCT不能用于COUNT(*)。 如：Select Distinct name From s_dept; Select Distinct dept_id,title From s_emp;
文本处理： TRIM()/LTRIM()/RTIRM()：去空格。只能去掉头和尾的空格，中间的不理。 trim(' heo Are fdou ') --> heo Are fdou 输入：select trim(' heo Are fdou ') from dual; -->：heo Are fdou LOWER：转小写 lower('SQL Course') --> sql course UPPER：转大写 upper(' SQL Course') --－>SQL COURSE INITCAP：首字母转大写，其余转小写 initcap(SQL Course') '--> Sql Course
转化： TO_CHAR(number,'fmt')：把数值转换成字符串 显示数字的命令 9：正常显示数字； 0：显示包括0的数值形式，空位强制补0； $：以美元符号显示货币； L：按当前环境显示相关的货币符号； . 和，：在固定位置出现“.”点 和“，”逗号；不够位时，四舍五入。 例题：SQL> select 'Order'||To_char(id)|| 2 'was filled for a total of' 3 ||To_char(total,'fm$9,999,999') 4 from s_ord 5 where ship_date ='21-SEP-92';
TO_NUMBER(char)：把字符转换成数字
九、链接 内链接：严格匹配两表的记录。 外链接分左链接和右链接: 会使用一方表中的所有记录去和另一格表中的记录按条件匹配，空值也会匹配，这个表中的所有记录都会显示， 数据库会模拟出记录去和那些不匹配的记录匹配。 左链接 加号在右面 如：有 TABLE1 TABLE2 1的一条记录在2里面没有匹配上，那么1里面的记录保留 2的一条记录在1里面没有匹配上 ，那么2丢弃 右链接正好相反 --例题：哪些人是领导。 select distinct b.id,b.last_name manager from s_emp a,s_emp b where a.manager_id=b.id(+); 左右顺序有区别，这是另外新建一个表，要显示的是第二个表格的内容。 +放在没有匹配行的表一侧，令表格能完整显示出来。
标准写法：内连接用INNER，左连接用LEFT，右连接用RIGHT。 select distinct b.id,b.last_name manager from s_emp a LEFT join s_emp b ON a.manager_id=b.id;
十、组函数： 分组允许将数据分为多个逻辑组，以便能对每个组进行聚集计算。 Group：分组 Group by：分组。(默认按升序对所分的组排序；想要降序要用 order by)可以包括任意数目的列。 如果嵌入了分组，数据将在最后规定的分组上进行汇总。 GROUP BY 子句中列出的每个列都必须是检索列或有效的表达式，但不能是聚集函数。 *如果在SELECT 中使用表达式，则必须在GROUP BY子句中指定相同的表达式，不能使用别名。 除聚合计算语句外，SELECT语句中的每个列都必须在GROUP BY子句中给出。 如果分组列中具有NULL值，则NULL将作为一个分组返回。如果列中有多行NULL，它们将分为一组。
子查询：查询语句的嵌套 可以用于任意select 语句里面，但子查询不能出现 order by。 子查询总是从内向外处理。作为子查询的SELECT 语句只能查询单个列，企图检索多个列，将会错误。 如：找出工资最低的人select min(last_name),min(salary) from s_emp; 或者用子查询select last_name,salary from s_emp where salary=(select min(salary) from s_emp);
INSERT：插入(或添加)行到数据库表中的关键字。 插入方式有以下几种：插入完整的行；插入行的一部分；插入某些查询的结果。 对于INSERT操作，可能需要客户机/服务器的DBMS中的特定的安全权限。 插入行(方式一) INSERT INTO products VALUES(2008,’TV’,222.22,’US’); 依赖于表中定义的顺序，不提倡使用。有空值时需要自己补上。 插入行(方式二) INSERT INTO products(id,name,price,vend_name) VALUES(2008,’TV’,222.22,’US’); 依赖于逻辑顺序，会自动补上空值，提倡使用。
插入检索出的数据：可以插入多条行到数据库表中 INSERT INTO products(*,*,*,*) SELECT *,*,*,* FROM products_copy; 如果这个表为空，则没有行被插入，不会产生错误，因为操作是合法的。 可以使用WHERE加以行过滤。
复制表： 将一个表的内容复制到一个全新的表(在运行中创建，开始可以不存在) CREATE TABLE 新表名 AS SELECT * FROM 表名;
INSERT INTO 与 CREATE TABLE AS SELECT 不同，前者是导入数据，而后者是导入表。 任何SELECT选项和子句都可以使用，包括WHERE和GROUP BY。 可利用联接从多个表插入数据。不管从多少个表中检索数据，数据都只能插入到单个表中。
更新数据 UPDATE 语句 需要提供以下信息：要更新的表；列名和新值；确定要更新的哪些行的过滤条件。 UPDATE 表名 SET vend_name = ‘HP’, prod_name = ‘NEWCOMPUTER’ WHERE vend_name = ‘IBM’; --UPDATE 语句中可以使用子查询，使得能用SELECT语句检索出的数据更新列数据。也可以将一个列值更新为 NULL。
删除数据 DELETE 语句 DELETE FROM products WHERE prod_name = ‘COMPUTER’; 全行删除，不要省略WHERE，注意安全。 DELETE不需要列名或通配符。删除整行而不是删除列。DELETE是删除表的内容而不是删除表。 如果想从表中删除所有内容，可以使用TRUNCATE TABLE语句(清空表格)，它更快。
数字字典表： Sequence:排列。存储物理地址
Index:索引。依附于表，为提高检索速度。
View:视图。看到表的一部分数据。 限制数据访问。简化查询。数据独立性。本质上是一个sql查询语句。 Create[or Relace][Force|noForce] View 视图名 [(alias[,alias]…)] 别名列表 As subquery [With Check Option [Constraint ……]] [With Read Only] 注意：有些DBMS不允许分组或排序视图，不能有 Order by 语句。可以有 Select 语句。 删除视图： DROP VIEW 视图名
Rownum:纬列。内存里排序的前N个。 在where语句中，可以用＝1，和<=N 或 N。 因为这是内存读取，没有1就丢弃再新建1。只能从1开始。需要从中间开始时，需二重子rownum语句需取别名。 经典应用： Top-n Analysis (求前N名或最后N名) Select [查询列表], Rownum From (Select [查询列表(要对应)] From 表 Order by Top-N_字段) Where Rownum <= N
分页显示： --取工资第5～10名的员工(二重子rownum语句，取别名) select rn,id,last_name,salary From ( select id,last_name,salary,Rownum rn From (Select id,last_name,salary from s_emp order by salary desc) where rownum <= 10) where rn between 5 and 10;
Union：合并表 Select … Union Select… 把两个Select语句的表合并。 要求两表的字段数目和类型按顺序对应。合并后的表，自动过滤重复的行。 Intersect：交。 同上例，把两个Select表相交。 Minus：减。 把相交的内容减去。 not exists 除运算。
添加字段(列)： Alter Table 表名 Add (column dataype [Default expr][Not Null] [,column datatype]…); 添加有非空限制的字段时，要加Default语句 字段名字不可以直接改名，需要添加新字段，再复制旧字段后删除旧字段。 添加约束： Alter Table 表名 Add [CONSTRAINT constraint] type (column); 添加非空约束时，要用Modify语句。 查看约束名时，可以违反约束再看出错提示；或者查看约束字典desc user_constraints
减少字段： Alter Table 表名 Drop (column [,column]…); 删除约束： Alter Table 表名 Drop CONSTRAINT column; 或： Alter Table 表名 Drop Primary Key Cascade;
暂时关闭约束，并非删除： Alter Table 表名 Disable CONSTRAINT column Cascade; 打开刚才关闭的约束： Alter Table 表名 Enable CONSTRAINTcolumn;
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml&q
// for循环的进化
// 菜鸟
for (var i = 0; i < Things.length ; i++) {
// Things[i]
}
// 老鸟
for (var i = 0, len = Things.length; i < len; i++) {
// Things[i]
}
// 大师
for (var i = Things.le
the idea is from:
http://blog.csdn.net/zhanxinhang/article/details/6731134
public class MaxSubMatrix {
/**see http://blog.csdn.net/zhanxinhang/article/details/6731134
* Q35
求一个矩阵中最大的二维
使用cordova可以很方便的在手机sdcard中读写文件。
首先需要安装cordova插件：file
命令为：
cordova plugin add org.apache.cordova.file
然后就可以读写文件了，这里我先是写入一个文件，具体的JS代码为：
var datas=null;//datas need write
var directory=&
SELECT cust_id,
SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
HAVING total > 250
db.orders.aggregate( [
{ $match: { status: 'A' } },
{
$group: {
