[Java] 总结1.5/1.6/1.7版本的特性

时间 2019-12-02

标签 java 总结 1.5 1.6 1.7 版本特性栏目 Java 繁體版

原文原文链接

开发过程当中接触到了从jdk1.5---jdk1.7的使用，在不一样的阶段，都使用过了jdk的一些新特性，操做起来更加方面啦！特此总结了下，如下是测试代码： java

JDK1.5新特性： git

1.自动装箱与拆箱：程序员

Integer iObj = 3;

System.out.println(iObj + 12);
Integer i1 = 137(-128--127范围时，为true);
Integer i2 = 137(-128--127范围时，为true);

System.out.println(i1 == i2); //false，可是括号中时却返回ture，缘由是Integer采用的是享元模式

Integer i3 = Integer.valueOf(213);
Integer i4 = Integer.valueOf(213);
System.out.println(i3==i4);//同上，另外一种包装形式

2.枚举(经常使用来设计单例模式) 正则表达式

public class EnumTest {

/**
* @param args
*/
public static void main(String[] args) {
   WeekDay1 weekDay = WeekDay1.MON;
   System.out.println(weekDay.nextDay());
   WeekDay weekDay2 = WeekDay.FRI;
   System.out.println(weekDay2);
   System.out.println(weekDay2.name());
   System.out.println(weekDay2.ordinal()); 
   System.out.println(WeekDay.valueOf("SUN").toString());
   System.out.println(WeekDay.values().length);
   new Date(300){};
}

public enum WeekDay{

   SUN(1),MON(),TUE,WED,THI,FRI,SAT;
   private WeekDay(){System.out.println("first");}
   private WeekDay(int day){System.out.println("second");}
}

public enum TrafficLamp{
   RED(30){
    public TrafficLamp nextLamp(){
     return GREEN;
    }
   },
   GREEN(45){
    public TrafficLamp nextLamp(){
     return YELLOW;
    }   
   },
   YELLOW(5){
    public TrafficLamp nextLamp(){
     return RED;
    }   
   };
   public abstract TrafficLamp nextLamp();
   private int time;
   private TrafficLamp(int time){this.time = time;}
}
}

3.静态导入数据库

import static java.lang.Math.*;

public class StaticImport {
public static void main(String[] args){
   int x = 1;
   try {
    x++;
   } finally {
    System.out.println("template");
   }
   System.out.println(x);
  
  
   System.out.println(max(3, 6));
   System.out.println(abs(3 - 6));
  
}
}

4.可变参数apache

public class VarableParameter {

/**
* @param args
*/
public static void main(String[] args) {

   System.out.println(add(2,3));
   System.out.println(add(2,3,5));  
}


public static int add(int x,int... args){
   int sum = x;
/*   for(int i=0;i<args.length;i++){
    sum += args[i];
   }*/
  
   for(int arg : args){
    sum += arg;
   }
   return sum;
}

}

5.内省编程

ReflectPoint pt1 = new ReflectPoint(3,5);

BeanInfo beanInfo = Introspector.getBeanInfo(pt1.getClass());
   PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
   Object retVal = null;
   for(PropertyDescriptor pd : pds){
     Method methodGetX = pd.getReadMethod();
     retVal = methodGetX.invoke(pt1);

   }

jdk1.6新特性：api

1.Web服务元数据数组

Java 里的Web服务元数据跟微软的方案基本没有语义上的区别,自从JDK5添加了元数据功能(Annotation)以后,SUN几乎重构了整个J2EE体系, 因为变化很大,干脆将名字也重构为Java EE, Java EE(当前版本为5.0)将元数据归入不少规范当中,这其中就包括Web Services的相关规范, 加入元数据以后的Web Services服务器端编程模型就跟上面看到的C#片段差很少了, 这显然比之前的JAX-RPC编程模型简单(固然, Axis的编程模型也很简单).这里要谈的Web服务元数据(JSR 181)只是Java Web 服务规范中的一个,它跟Common Annotations, JAXB2, StAX, SAAJ和JAX-WS等共同构成Java EE 5的Web Services技术堆栈.浏览器

package WebServices;

import java.io.File;
import java.io.IOException;
import javax.jws.Oneway;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;
import javax.xml.ws.Endpoint;

/**
* @author chinajash
*/
@WebService(targetNamespace="http://blog.csdn.net/chinajash",serviceName="HelloService")
public class WSProvider {
     @WebResult(name="Greetings")//自定义该方法返回值在WSDL中相关的描述    
     @WebMethod
     public String sayHi(@WebParam(name="MyName") String name){
         return "Hi,"+name; //@WebParam是自定义参数name在WSDL中相关的描述
     }    
     @Oneway //代表该服务方法是单向的,既没有返回值,也不该该声明检查异常
     @WebMethod(action="printSystemTime",operationName="printSystemTime")//自定义该方法在WSDL中相关的描述
     public void printTime(){
         System.out.println(System.currentTimeMillis());
     }
     public static void main(String[] args) {
         Thread wsPublisher = new Thread(new WSPublisher());
         wsPublisher.start();
     }    
     private static class WSPublisher implements Runnable{
         public void run() {
             //发布WSProvider到http://localhost:8888/chinajash/WSProvider这个地址,以前必须调用wsgen命令
             //生成服务类WSProvider的支持类,命令以下:
             //wsgen -cp . WebServices.WSProvider
             Endpoint.publish("http://localhost:8888/chinajash/WSProvider",new WSProvider());
         }        
     }
}

若是想看到Web Services Engine生成的WSDL文件是否遵照上面的元数据, 咱们没有必要将上面的WSProvider部署到支持JSR-181的应用服务器或Servlet形式的Web Services Engine,如今JDK6已经提供了一个很简单的机制能够用来测试和发布Web Services,下面讲讲如何在JDK6环境下发布Web Services和查看生成的WSDL
1.将<JDK_HOME>/bin加入path环境变量
2.在命令行下切换当前目录到WSProvider的class文件所在的目录,运行下面命令
wsgen -cp . WebServices.WSProvider
在这个例子中会生成如下3个类的源代码文件及class文件
SayHi
SayHiResponse
PrintTime

3.执行以下代码发布WSProvider到http://localhost:8888/chinajash/WSProvider,在这里能够执行WSProvider类的main方法就能够
Endpoint.publish("http://localhost:8888/chinajash/WSProvider",new WSProvider());

4.在浏览器输入http://localhost:8888/chinajash/WSProvider?wsdl就能够看到生成的WSDL文件，为了节省篇幅,这里就不把生成的WSDL文件贴上了，你们能够本身动手试试.

2.脚本语言支持

JDK6增长了对脚本语言的支持(JSR 223)，原理上是将脚本语言编译成bytecode，这样脚本语言也能享用Java平台的诸多优点，包括可移植性，安全等，另外，因为如今是编译成 bytecode后再执行，因此比原来边解释边执行效率要高不少。加入对脚本语言的支持后，对Java语言也提供了如下好处。
一、许多脚本语言都有动态特性，好比，你不须要用一个变量以前先声明它，你能够用一个变量存放彻底不一样类型的对象，你不须要作强制类型转换，由于转换都是自动的。如今Java语言也能够经过对脚本语言的支持间接得到这种灵活性。
二、能够用脚本语言快速开发产品原型，由于如今能够Edit-Run，而无需Edit-Compile-Run，固然，由于Java有很是好的IDE支持，我们彻底能够在IDE里面编辑源文件，而后点击运行(隐含编译)，以此达到快速开发原型的目的，因此这点好处基本上能够忽略。
三、经过引入脚本语言能够轻松实现Java应用程序的扩展和自定义，咱们能够把原来分布在在Java应用程序中的配置逻辑，数学表达式和业务规则提取出来，转用JavaScript来处理。
Sun的JDK6实现包含了一个基于Mozilla Rhino的脚本语言引擎，支持JavaScript，这并非说明JDK6只支持JavaScript，任何第三方均可以本身实现一个JSR-223兼容的脚本引擎使得JDK6支持别的脚本语言，好比，你想让JDK6支持Ruby，那你能够本身按照JSR 223的规范实现一个Ruby的脚本引擎类，具体一点，你须要实现javax.script.ScriptEngine(简单起见，能够继承 javax.script.AbstractScriptEngine)和javax.script.ScriptEngineFactory两个接口。固然，在你实现本身的脚本语言引擎以前，先到scripting.dev.java.net project 这里看看是否是有人已经帮你作了工做，这样你就能够直接拿来用就行。
Scripting API
--------------------------------------------------------------------------------
Scripting API是用于在Java里面编写脚本语言程序的API，在Javax.script中能够找到Scripting API，咱们就是用这个API来编写JavaScript程序，这个包里面有一个ScriptEngineManager类，它是使用Scripting API的入口，ScriptEngineManager能够经过jar服务发现(service discovery)机制寻找合适的脚本引擎类(ScriptEngine)，使用Scripting API的最简单方式只需下面三步
一、建立一个ScriptEngineManager对象
二、经过ScriptEngineManager得到ScriptEngine对象
三、用ScriptEngine的eval方法执行脚本
下面是一个Hello World程序

/** * @author chinajash */public class HelloScript {public static void main(String[] args) throws Exception {         ScriptEngineManager factory = new ScriptEngineManager();//step 1         ScriptEngine engine = factory.getEngineByName("JavaScript");//Step 2             engine.eval("print('Hello, Scripting')");//Step 3     }     }运行上面程序，控制台会输出Hello, Scripting上面这个简单的Scripting程序演示了如何在Java里面运行脚本语言，除此以外，咱们还能够利用Scripting API实现如下功能一、暴露Java对象为脚本语言的全局变量二、在Java中调用脚本语言的方法三、脚本语言能够实现Java的接口四、脚本语言能够像 Java同样使用JDK平台下的类下面的类演示了以上4种功能package Scripting;import java.io.File;import javax.script.Invocable;import javax.script.ScriptEngine;import javax.script.ScriptEngineManager;import javax.script.ScriptException;/** * @author chinajash */public class ScriptingAPITester {     public static void main(String[] args) throws Exception {         ScriptEngineManager manager = new ScriptEngineManager();         ScriptEngine engine = manager.getEngineByName("JavaScript");         testScriptVariables(engine);//演示如何暴露Java对象为脚本语言的全局变量          testInvokeScriptMethod(engine);//演示如何在Java中调用脚本语言的方法          testScriptInterface(engine);//演示脚本语言如何实现Java的接口          testUsingJDKClasses(engine);//演示脚本语言如何使用JDK平台下的类     }         public static void testScriptVariables(ScriptEngine engine) throws ScriptException{         File file = new File("test.txt");         engine.put("f", file);         engine.eval("println('Total Space:'+f.getTotalSpace())");             }         public static void testInvokeScriptMethod(ScriptEngine engine) throws Exception{         String script = "function hello(name) { return 'Hello,' + name;}";         engine.eval(script);         Invocable inv = (Invocable) engine;         String res = (String)inv.invokeFunction("hello", "Scripting" );         System.out.println("res:"+res);     }         public static void testScriptInterface(ScriptEngine engine) throws ScriptException{         String script = "var obj = new Object(); obj.run = function() { println('run method called'); }";         engine.eval(script);         Object obj = engine.get("obj");         Invocable inv = (Invocable) engine;         Runnable r = inv.getInterface(obj,Runnable.class);         Thread th = new Thread(r);         th.start();     }         public static void testUsingJDKClasses(ScriptEngine engine) throws Exception{         //Packages是脚本语言里的一个全局变量,专用于访问JDK的package         String js = "function doSwing(t){var f=new Packages.javax.swing.JFrame(t);f.setSize(400,300);f.setVisible(true);}";         engine.eval(js);         Invocable inv = (Invocable) engine;         inv.invokeFunction("doSwing", "Scripting Swing" );     }}Scripting Tool

SUN提供的JDK6中有一个命令行工具??jrunscript，你能够在<JDK6_Home>/bin下面找到这个工具，jrunscript是一个脚本语言的解释程序，它独立于脚本语言，但默认是用JavaScript，咱们能够用jrunscript来测试本身写的脚本语言是否正确，下面是一个在命令行运行jrunscript的简单例子
jrunscript
js>println("Hello,JrunScript");
Hello,JrunScript
js>9*8
72.0
js>
3.JTable的排序和过滤

原来的JTable基本上是只能显示数据，在JDK6新增了对JTable的排序和过滤功能，下面代码演示了这两个功能

/**
* @author chinajash
*/
public class JTableTester {
     static String data[][] = {
         {"China","Beijing","Chinese"},
         {"America","Washington","English"},
         {"Korea","Seoul","Korean"},
         {"Japan","Tokyo","Japanese"},
         {"France","Paris","French"},
         {"England","London","English"},
         {"Germany","Berlin","German"},
     };
     static String titles[] = {"Country","Capital","Language"};
     public static void main(String[] args) {        
         DefaultTableModel m = new DefaultTableModel(data,titles);
         JTable t = new JTable(m);
         final TableRowSorter sorter = new TableRowSorter(m); 
         t.setRowSorter(sorter); //为JTable设置排序器
        
         JScrollPane sPane = new JScrollPane();
         sPane.setViewportView(t);
        
         JPanel p = new JPanel();
         p.setLayout(new BoxLayout(p,BoxLayout.X_AXIS));
         JLabel l = new JLabel("Criteria:");
         final JTextField tf = new JTextField();
         JButton b = new JButton("Do Filter");
         p.add(l);
         p.add(tf);
         p.add(b);
         b.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 if(tf.getText().length()==0){
                     sorter.setRowFilter(null);
                 }else{
                     sorter.setRowFilter(RowFilter.regexFilter(tf.getText()));//为JTable设置基于正则表达式的过滤条件
                 }
             }
         });
        
         JFrame f = new JFrame("JTable Sorting and Filtering");
         f.getContentPane().add(sPane,BorderLayout.CENTER);        
         f.getContentPane().add(p,BorderLayout.SOUTH);
         f.setSize(400,300);
         f.setVisible(true);
     }
}

运行上面程序，单击JTable的某一个title，这个title对应的列就会按照升序/降序从新排列；在下面的Criteria文本框中输入"ese"，点击"Do Filter"按钮，JTable将只显示带有"ese"字符串的行，也就是China和Japan两行，若是文本框里面什么都没有，点击"Do Filter"按钮，这时JTable会显示全部的行。
4.更简单,更强大的JAX-WS

JAX-WS2.0的来历
--------------------------------------------------------------------------------
JAX-WS(JSR-224) 是Java Architecture for XML Web Services的缩写,简单说就是一种用Java和XML开发Web Services应用程序的框架, 目前版本是2.0, 它是JAX-RPC 1.1的后续版本, J2EE 1.4带的就是JAX-RPC1.1, 而Java EE 5里面包括了JAX-WS 2.0,但为了向后兼容,仍然支持JAX-RPC. 如今,SUN又把JAX-WS直接放到了Java SE 6里面,因为JAX-WS会用到Common Annotation(JSR 250),Java Web Services Metadata(JSR 181), JAXB2(JSR 222), StAX(JSR 173), 因此SUN也必须把后几个原属于Java EE范畴的Components下放到Java SE, 如今咱们能够清楚地理解了为何Sun要把这些看似跟Java SE没有关系的Components放进来,终极目的就是要在Java SE里面支持Web Services.
JAX-WS2.0的架构
--------------------------------------------------------------------------------
JAX-WS不是一个孤立的框架,它依赖于众多其余的规范,本质上它由如下几部分组成
1.用来开发Web Services的Java API
2.用来处理Marshal/Unmarshal的XML Binding机制,JAX-WS2.0用JAXB2来处理Java Object与XML之间的映射,Marshalling就是把Java Object映射到XML,Unmarshalling则是把XML映射到Java Object.之因此要作Java Object与XML的映射,是由于最终做为方法参数和返回值的Java Object要经过网络传输协议(通常是SOAP)传送,这就要求必须对Java Object作相似序列化和反序列化的工做,在SOAP中就是要用XML来表示Java object的内部状态
3.众多元数据(Annotations)会被JAX-WS用来描述Web Services的相关类,包括Common Annotations, Web Services Metadata, JAXB2的元数据和JAX-WS2.0规范本身的元数据.
4.Annotation Processing Tool(APT)是JAX-WS重要的组成部分,因为JAX-WS2.0规范用到不少元数据,因此须要APT来处理众多的Annotations. 在<JDK_HOME>/bin下有两个命令wsgen和wsimport,就是用到APT和Compiler API来处理碰到的Annotations,wsgen能够为Web Services Provider产生并编译必要的帮助类和相关支持文件,wsimport以WSDL做为输入为Web Service Consumer产生并编译必要的帮助类和相关支持文件.
5.JAX-WS还包括JAX-WS Runtime与应用服务器和工具之间的契约关系
JAX-WS2.0的编程模型
--------------------------------------------------------------------------------
如今用JAX-WS2.0来编写Web Services很是简单,不像JAX-RPC,JAX-WS能够把任意POJO暴露为Web Services,服务类不须要实现接口,服务方法也没有必要抛出RMI异常.下面介绍在JDK6环境下用JAX-WS2.0开发和测试Web Services的步骤
1.编写服务类,并用Web Services Metadata(JSR-181)标注这个服务类,我用个人另外一篇BlogJDK6的新特性之十:Web服务元数据中的WSProvider类做为服务类的例子,在此我重复贴一下WSProvider类的源代码:

/**
* @author chinajash
*/
@WebService(targetNamespace="http://blog.csdn.net/chinajash",serviceName="HelloService")
public class WSProvider {
     @WebResult(name="Greetings")//自定义该方法返回值在WSDL中相关的描述    
     @WebMethod
     public String sayHi(@WebParam(name="MyName") String name){
         return "Hi,"+name; //@WebParam是自定义参数name在WSDL中相关的描述
     }    
     @Oneway //代表该服务方法是单向的,既没有返回值,也不该该声明检查异常
     @WebMethod(action="printSystemTime",operationName="printSystemTime")//自定义该方法在WSDL中相关的描述
     public void printTime(){
         System.out.println(System.currentTimeMillis());
     }
     public static void main(String[] args) {
         Thread wsPublisher = new Thread(new WSPublisher());
         wsPublisher.start();
     }    
     private static class WSPublisher implements Runnable{
         public void run() {
             //发布WSProvider到http://localhost:8888/chinajash/WSProvider这个地址,以前必须调用wsgen命令
             //生成服务类WSProvider的支持类,命令以下:
             //wsgen -cp . WebServices.WSProvider
             Endpoint.publish("http://localhost:8888/chinajash/WSProvider",new WSProvider());
         }        
     }
}

2.用wsgen生成上面服务类的必要的帮助类,而后调用用EndPoint类的静态方法publish发布服务类(步骤请参考个人另外一篇Blog JDK6的新特性之十:Web服务元数据),我在这里是将服务类发布到http://localhost:8888/chinajash /WSProvider
3.用wsimport为服务消费者(也就是服务的客户端)生成必要的帮助类,命令以下:
wsimport http://localhost:8888/chinajash/WSProvider?wsdl
这会在<当前目录>netcsdnblogchinajash下生成客户端的帮助类,在这个例子中会生成7个类
HelloService.class
ObjectFactory.class
package-info.class
PrintSystemTime.class
SayHi.class
SayHiResponse.class
WSProvider.class
4.在客户端用下面代码便可调用步骤1定义的Web Service
HelloService hs = new HelloService();
WSProvider ws = hs.getWSProviderPort();
System.out.println(ws.sayHi("chinajash"));
ws.printSystemTime();
调用上述代码后客户端控制台输出
hi,chinajash
服务端控制台输出服务器当前系统时间
5.轻量级Http Server

JDK6的新特性之五:轻量级Http Server
JDK6提供了一个简单的Http Server API,据此咱们能够构建本身的嵌入式Http Server,它支持Http和Https协议,提供了HTTP1.1的部分实现，没有被实现的那部分能够经过扩展已有的Http Server API来实现,程序员必须本身实现HttpHandler接口,HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求,在这里,咱们把一个Http请求和它的响应称为一个交换,包装成HttpExchange类,HttpServer负责将HttpExchange传给 HttpHandler实现类的回调方法.下面代码演示了怎样建立本身的Http Server

/**
* Created by IntelliJ IDEA.
* User: Chinajash
* Date: Dec 30, 2006
*/
public class HTTPServerAPITester {
     public static void main(String[] args) {
         try {
             HttpServer hs = HttpServer.create(new InetSocketAddress(8888),0);//设置HttpServer的端口为8888
             hs.createContext("/chinajash", new MyHandler());//用MyHandler类内处理到/chinajash的请求
             hs.setExecutor(null); // creates a default executor
             hs.start();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
}

class MyHandler implements HttpHandler {
    public void handle(HttpExchange t) throws IOException {
        InputStream is = t.getRequestBody();
        String response = "<h3>Happy New Year 2007!--Chinajash</h3>";
        t.sendResponseHeaders(200, response.length());
        OutputStream os = t.getResponseBody();
        os.write(response.getBytes());
        os.close();
    }
}

运行程序后,在浏览器内输入http://localhost:8888/xx,浏览器输出
6.嵌入式数据库 Derby

Derby是IBM送给开源社区的又一个礼物，是一个pure java的数据库，如今已经被列入到java1.6中。
不知道对于大数据量的性能如何，但传说中启动derby只会给JVM添加2M的内存，对那些小数据库应用，好比像用access那种应该是挺有诱惑力的。
另外，麻雀虽小，五脏俱全，功能要比access多得多咯，包括事务处理，并发，触发器都有，管理又简单，所以本身用来作点工具正好合适。
废话少说，介绍一下我折腾了半天的经验吧。
个人Derby配置过程：
1，下载db-derby-10.1.3.1-bin.tar.gz,derby_core_plugin_10.1.3.zip和derby_ui_plugin_1.1.0.zip，把两个插件安装到eclipse上
2，打开ecllipse,新建一个project
3，右键这个project，选择Apache Derby，再选择add apache derby native，发现只是给个人project添加了几个derby的jar，还不是在我看着顺眼的lib目录里，索性干掉，换上db-derby- 10.1.3.1-bin.tar.gz解压出来之后lib目录下的jar文件，在Build Path里设置一下；
4，右键Project，在apache derby里选择start apache derby network server，控制台能够看到derby启动后打出的“服务器准备在端口 1527 上接受链接。”
5，右键Project，在apache derby里选择ij(Interactive SQL)，启动SQL控制台；
6，输入connect jdbc:derby:testdb;create=true; 注意要有单引号，能够在工程跟目录下建立testdb数据库，能够看到一个新建的目录testdb，那里的文件就是数据库咯；
7，用标准的SQL语句来建一个数据库试试：
create table test (a varchar(4) not null, b char(2) primary key);
竟然能够用，太神奇了，呵呵
8，再插入一条语句试试呢，insert into test(a,b) values(a,11);，嗯，不错，能够用select 查出来的哦。
9，再插一下：insert into test(a,b) values(a,11);，哦哦，报错了，“错误 23505：语句异常终止，由于它致使“TEST”上所定义的“SQL060710092132480”标识的惟一或主键约束或惟一索引中出现重复键值。” 呵呵。
10，好了，如今能够像你控制的其余数据库同样来控制Derby了。
若是上述方法不行，或者你习惯了在eclipse以外使用和管理数据库，那么能够很方便的把Derby“装”在系统里。下面我说一下步骤：
1，把db-derby-10.1.3.1-bin.tar.gz解压到c:derby,使lib和framework两个目录在c:derby下边便可
2，设置环境变量
设置一个c:derbyframeworkembededbin或c:derbyframeworkNetworkServebin到Path中，这样咱们就能够直接执行上边介绍的connect这样的命令而不用每次钻到那个目录下去执行了
设置c:derbylibderby.jar;c:derbylibderbytoos.jar到CLASSPATH中，以便让这些java编成的命令可以正确执行；
3，打开cmd
4，敲入startNetworkServer，能够看到像在eclisp中提示的那样启动了server
5，再打开一个cmd,敲入sysinfo,能够看到derby的环境信息了，注意在java user dir这一项，也许是java用户目录上和上边看到的会有所不一样哦，这样在connect jdbc:derby:testdb;create=true;的建的数据库目录就不同咯。
6，敲入ij，好了，进入到上边的交互界面，能够建一个数据库看看了。
7，最后在另一个cmd中敲入stopNetworkServer就能够关闭数据库了。
若是你两种方法都试过了，那么须要注意的，仍是上边步骤5的问题，这个问题是你可能随时会启动一个数据库或新建一个数据库，但若是你刚刚使用derby，你可能尚未察觉。
derby实际上有两种启动方式，一种是嵌入式的，一种是网络服务器的启动。
1，咱们在eclipse中右键start apache derby network server那个，就是网络服务器的启动方式，在这种方式下能够用另一台计算机在ij中以：
connect jdbc:derby://192.168.0.28:1527/testdb
的方式进行连接。
2，第二种启动方式是在ij里边就直接
connect jdbc:derby:testdb
这实际是在连当前配置环境下java user dir下那个目录的数据库。
看到这里可能有点糊涂了，这么就会出问题了那？
实际上derby的访问更像是一种使用derby driver对本地文件系统的访问，无论启动不启动网络服务器，均可以用driver访问本地的数据库。这样，在ij里边像第二种方式那样创建链接是彻底能够的。启动了网络服务器，只不过是可以让其余主机访问罢了。
另一个问题是，在eclipse中和在系统中链接服务器，在connect的时候这个当前配置环境是不同的，eclipse默认工程所在路径是数据库的所在路径，而在系统中“装”derby则会认为 c:document and settings下边那个用户目录是数据库的所在路径。
jdk1.7新特性：

1，switch中可使用字串了

String s = "test";   
switch (s) {   
case "test" :   
     System.out.println("test"); 
case "test1" :   
    System.out.println("test1"); 
    break ;   
default :   
    System.out.println("break"); 
    break ;   
}

2.运用List<String> tempList = new ArrayList<>(); 即泛型实例化类型自动推断
3.语法上支持集合，而不必定是数组

final List<Integer> piDigits = [ 1,2,3,4,5,8 ];
4.新增一些取环境信息的工具方法

File System.getJavaIoTempDir() // IO临时文件夹

File System.getJavaHomeDir() // JRE的安装目录

File System.getUserHomeDir() // 当前用户目录

File System.getUserDir() // 启动java进程时所在的目录5

5.Boolean类型反转，空指针安全,参与位运算

Boolean Booleans.negate(Boolean booleanObj)

True => False , False => True, Null => Null

boolean Booleans.and(boolean[] array)

boolean Booleans.or(boolean[] array)

boolean Booleans.xor(boolean[] array)

boolean Booleans.and(Boolean[] array)

boolean Booleans.or(Boolean[] array)

boolean Booleans.xor(Boolean[] array)

6.两个char间的equals
boolean Character.equalsIgnoreCase(char ch1, char ch2)
7.安全的加减乘除
int Math.safeToInt(long value)

int Math.safeNegate(int value)

long Math.safeSubtract(long value1, int value2)

long Math.safeSubtract(long value1, long value2)

int Math.safeMultiply(int value1, int value2)

long Math.safeMultiply(long value1, int value2)

long Math.safeMultiply(long value1, long value2)

long Math.safeNegate(long value)

int Math.safeAdd(int value1, int value2)

long Math.safeAdd(long value1, int value2)

long Math.safeAdd(long value1, long value2)

int Math.safeSubtract(int value1, int value2)

8.map集合支持并发请求，且能够写成 Map map = {name:"xxx",age:18};