java

实现了java.io.Serializable接口才能被序列化，而list本身是一个接口，也没继承java.io.Serializable，不存在序列化一说，但是它的子类ArrayList是可以被序列化的：public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Serializable

您好，提问者： <?代表传过来的类型，extends表示传过来的必须是Serializable的子类> 这是代表向下转型，向上转型是<? super xxx>

Serializable的哪个id是没用任何用的。想得到id很简单，，比如你的是 UserUser.serialVersionUID

看看你那个类的类名下面有没有波浪线，是警告的提示，然后鼠标放在上面，会出现提示的，点击一下就出来了

实现java.io.Serializable接口就行。

不需要,只要引用Serializable接口就可以了,序列化工作由java自动完成.如果想了解原理可以搜索下Serializable原理.

实现序列化接口 网络传输实体必需实现这个接口

你想表达什么?long转intlong l = 111111l; int i = (int) l;Integer.parseInt()只能将String转换成int

有很多网络传输使用的都是Serializable它可以先将代码保存为io，然后在反序列化回来了。如果是android，实现这个接口，可以实现对象的传递。

用来序列化象以便在网络上进行传输，在RMI和CORBA中会用到。

JDOMXPATH 等方法，解析XML，，，，，POI导出到EXCEL

在定义Serializable接口时，就没有定义任何的抽象方法，它只是作为对象序列化的一个标志而已，没有这个标志则该对象不能实现序列化与反序列化

我们有时候将一个java 对象变成字节流的形式传出去或者从一个字节流中恢复成一个java 对象，例如，要将java 对象存储到硬盘或者传送给网络上的其他计算机，这个过程我们可以自己写代码去把一个java 对象变成某个格式的字节流再传输，但是，jre 本身就提供了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java帮我们做，要被传输的对象必须实现serializable 接口，这样，javac 编译时就会进行特殊处理，编译的类才可以被writeObject方法操作，这就是所谓的序列化。需要被序列化的类必须实现Serializable 接口，该接口是一个mini 接口，其中没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。例如，在web 开发中，如果对象被保存在了Session 中，tomcat 在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi 等远程调用，这就需要在网络上传输对象，被传输的对象就必须实现Serializable接口。还有什么问题可以百度hi我

有关java的问题，这里都有很详细的讲解，你可以参考一下，方法有很多参考资料:http://www.baidu.com/s?wd=%B1%B1%B7%E7%CD%F8&rsv_bp=0&rsv_spt=3&inputT=422

int:Integerlong:Longjdk1.5自动装箱，int会自转换为Integer,而Integer是实现了Serializable的，所以可以。jdk1.4不自动装箱拆箱，所以要手动构造new Integer(int) new Long(long)/** * Constructs a newly allocated <code>Integer</code> object that * represents the <code>int</code> value indicated by the * <code>String</code> parameter. The string is converted to an * <code>int</code> value in exactly the manner used by the * <code>parseInt</code> method for radix 10. * * @param s the <code>String</code> to be converted to an * <code>Integer</code>. * @exception NumberFormatException if the <code>String</code> does not * contain a parsable integer. * @see java.lang.Integer#parseInt(java.lang.String, int) */ public Integer(String s) throws NumberFormatException { this.value = parseInt(s, 10); }

第一个方法public Object get(Class clazz,Serializable id);就是根据id查对象

继承了Serializable 接口的 参数都可以；常用的是 String 类；

我们有时候将一个java 对象变成字节流的形式传出去或者从一个字节流中恢复成一个java 对象，例如，要将java 对象存储到硬盘或者传送给网络上的其他计算机，这个过程我们可以自己写代码去把一个java 对象变成某个格式的字节流再传输，但是，jre 本身就提供了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java帮我们做，要被传输的对象必须实现serializable 接口，这样，javac 编译时就会进行特殊处理，编译的类才可以被writeObject方法操作，这就是所谓的序列化。需要被序列化的类必须实现Serializable 接口，该接口是一个mini 接口，其中没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。例如，在web 开发中，如果对象被保存在了Session 中，tomcat 在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi 等远程调用，这就需要在网络上传输对象，被传输的对象就必须实现Serializable接口。

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和恢复超类型的公用 (public)、受保护的 (protected) 和（如果可访问）包 (package) 字段的状态。仅在子类型扩展的类有一个可访问的无参数构造方法来初始化该类的状态时，才可以假定子类型有此职责。如果不是这种情况，则声明一个类为可序列化类是错误的。该错误将在运行时检测到。

一般是关注什么时候需要用Serializable 换个角度吧...

这个是可以通过工具生成的。不能随便定义。如果一个系统中两个类的serialVersionUID相同，会发生不可预知的情况。

不一定要 根据需求 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。 序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。是对象永久化的一种机制。　　 确切的说应该是对象的序列化，一般程序在运行时，产生对象，这些对象随着程序的停止运行而消失，但如果我们想把某些对象（因为是对象，所以有各自不同的特性）保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象。这种情况下就要用到对象的序列化。　　 只有序列化的对象才可以存储在存储设备上。为了对象的序列化而需要继承的接口也只是一个象征性的接口而已，也就是说继承这个接口说明这个对象可以被序列化了，没有其他的目的。之所以需要对象序列化，是因为有时候对象需要在网络上传输，传输的时候需要这种序列化处理，从服务器硬盘上把序列化的对象取出，然后通过网络传到客户端，再由客户端把序列化的对象读入内存，执行相应的处理。　　 对象序列化是java的一个特征，通过该特征可以将对象写作一组字节码，当在其他位置读到这些字节码时，可以依此创建一个新的对象，而且新对象的状态与原对象完全相同。为了实现对象序列化，要求必须能够访问类的私有变量，从而保证对象状态能够正确的得以保存和恢复。相应的，对象序列化API能够在对象重建时，将这些值还原给私有的数据成员。这是对java语言访问权限的挑战。通常用在服务器客户端的对象交换上面，另外就是在本机的存储。　　 对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。譬如通过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口

是一个接口 当你想要序列化对象时就要实现这个接口 把方法都封装好了 你直接调用就好了

一个对象序列化的接口，一个类只有实现了Serializable接口，它的对象才是可序列化的。因此如果要序列化某些类的对象，这些类就必须实现Serializable接口。而实际上，Serializable是一个空接口，没有什么具体内容，它的目的只是简单的标识一个类的对象可以被序列化。好处：a)比如说你的内存不够用了，那计算机就要将内存里面的一部分对象暂时的保存到硬盘中，等到要用的时候再读入到内存中，硬盘的那部分存储空间就是所谓的虚拟内存。在比如过你要将某个特定的对象保存到文件中，我隔几天在把它拿出来用，那么这时候就要实现Serializable接口；b)在进行java的Socket编程的时候，你有时候可能要传输某一类的对象，那么也就要实现Serializable接口；最常见的你传输一个字符串，它是JDK里面的类，也实现了Serializable接口，所以可以在网络上传输。c)如果要通过远程的方法调用（RMI）去调用一个远程对象的方法，如在计算机A中调用另一台计算机B的对象的方法，那么你需要通过JNDI服务获取计算机B目标对象的引用，将对象从B传送到A，就需要实现序列化接口。

下面是在D盘下，People.xml文件：Plain Text code?<?xml version="1.0" encoding="ISO-8859-1"?><people><person><first>Dr. Bunsen</first><last>Honeydew</last></person><person><first>Gonzo</first><last>The Great</last></person><person><first>Phillip J.</first><last>Fry</last></person></people>下面是java文件：Java code?import java.util.ArrayList;import nu.xom.Builder;import nu.xom.Document;import nu.xom.Elements;public class People extends ArrayList<Person>{public People(String fileName) throws Exception{Document doc = new Builder().build(fileName);Elements elements = doc.getRootElement().getChildElements();for(int i = 0;i<elements.size();i++)add(new Person(elements.get(i)));}public static void main(String[] args) throws Exception{People p = new People("d:\People.xml");System.out.println(p);} }运行环境是netbeans 8.0.2，错误如下所示：Plain Text code?Exception in thread "main" com.sun.org.apache.xerces.internal.util.URI$MalformedURIException: Opaque part contains invalid character: at com.sun.org.apache.xerces.internal.util.URI.initializePath(URI.java:1142)at com.sun.org.apache.xerces.internal.util.URI.initialize(URI.java:702)at com.sun.org.apache.xerces.internal.util.URI.<init>(URI.java:314)at com.sun.org.apache.xerces.internal.impl.XMLEntityManager.expandSystemId(XMLEntityManager.java:2037)at com.sun.org.apache.xerces.internal.impl.XMLEntityManager.setupCurrentEntity(XMLEntityManager.java:612)at com.sun.org.apache.xerces.internal.impl.XMLEntityManager.startEntity(XMLEntityManager.java:1300)at com.sun.org.apache.xerces.internal.impl.XMLEntityManager.startDocumentEntity(XMLEntityManager.java:1252)at com.sun.org.apache.xerces.internal.impl.XMLDocumentScannerImpl.setInputSource(XMLDocumentScannerImpl.java:257)at com.sun.org.apache.xerces.internal.parsers.DTDConfiguration.parse(DTDConfiguration.java:508)at com.sun.org.apache.xerces.internal.parsers.DTDConfiguration.parse(DTDConfiguration.java:590)at com.sun.org.apache.xerces.internal.parsers.XMLParser.parse(XMLParser.java:141)at com.sun.org.apache.xerces.internal.parsers.AbstractSAXParser.parse(AbstractSAXParser.java:1213)at nu.xom.Builder.build(Unknown Source)at nu.xom.Builder.build(Unknown Source)at xml.People.<init>(People.java:21)at xml.People.main(People.java:27)Java Result: 1

在java中把xml文件转换成json格式1、前提需要jar包： json-lib-2.4-jdk15.jar 和 xom-1.2.5.jar ，maven 仓库： net.sf.json-lib json-lib 2.4 jdk15 xom xom 1.2.5 2、代码部分： public static JSON xmlToJson(String xml) { XMLSerializer xmlSerializer = new XMLSerializer(); if(xml!=null && !”“.equals(xml)){ xml = xml.replaceAll(“ | ”, “”); JSON json = xmlSerializer.read(xml); return json; }else{ return null; }}public static void main(String[] args) {String xmlStr = "<parent><id>01</id<name>marry</name</parent>";JSON json = xmlToJson(xmlStr);System.out.println(json.toString());}3、结果： {“id”:”01”,”name”:”marry”}

1、利用纸和笔进行计算十进制的小数转换为二进制小数，主要是利用小数部分乘2，取整数部分，直至小数点后为0。下面以十进制的0.625为例，将它转化成二进制将小数部分0.625乘2，取整数部分1，如图：用剩余的小数部分0.25乘2，取整数部分0，如图：将剩余的小数部分0.5乘2，取整数部分。2、移位位运算中大多数操作都是向左移位和向右移位在Java中，这对应着>这两个操作符，示例如下：1234567891011/*000000011/*000000011/*11111111111111111111111111110000>>4=1111111111111。3、可以运用jdk工具监控java应用性能，再配合jmeter进行了一个长时间的加压，在加压过程中重点关注了系统资源的使用情况D：ProgramFiles(x86)Javajdk1.8.0_111in这个目录下的工具jps-ListstheinstrumentedJav。

参考一下：当你使用命令行的形式运行.class文件时,向你的类传递参数. C:>java YourClassName 参数1 [参数2 参数3 ....] 参数之间用一个空格作为间隔符.String[] args 这个字符串数组是保存运行main函数时输入的参数的，例如main函数所在的类名为test 那么你在cmd运行 java test a b c 时，args[0] = a ,args[1]=b, args[2]=c 你就可以在你的程序中调用你输入的这些变量了。args[]不就是那个字符串This is a simple Java program吗？－－－－－－－完全不是的，你理解不对。这样好了，你在运行的时候加个参数，比如 java test XX。然后在你的main函数里面加这段话：System.out.println("arg is"+args[0])，然后看看输出是什么？是不是这个：This is a simple Java programarg is XX在运行时输入java test xx yy zz,并且在你的main函数里面加这段话：System.out.println("arg is"+args[0]+" "+args[1]+" "+args[2])，然后看看输出是什么？是不是：This is a simple Java programarg is xx yy zz现在你理解了吗。。。如果没关系，为什么程序中去掉String args[]会出现错误？－－－－－－－－之所以去掉会出错在于，不带String args[]的main函数和带String args[]的main函数，本质上已经不是同一个函数了，java 本身不存在不带String args[]的main函数，所以当然出错了。另外,虚机团上产品团购,超级便宜

歌曲名:Oceano歌手:Djavan专辑:Puzzle Of HeartsJosh Groban - OceanoPiove sull"Oceanopiove sull"Oceanopiove sulla mia identitaLampi sull"Oceanolampi sull"Oceanosquarci di luminositaForse la in Americai venti del Pacificoscoprono le sue immensitale mie mani stringonosogni lontanissimie il mio pensiero corre da teRemo, tremo, sentoprofondi, oscuri abissiE"per l"amore che ti doe per l"amore che non saiche mi fai naufragareE"per l"amore che non hoe per l"amore che vorreie"per questo doloreE"questo amore che ho per teche mi fa superare queste vere tempesteOnde sull"OceanoOnde sull"Oceanoche dolcemente si placheraLe mie mani stringonosogni lontanissimie il tuo respiro soffia su meRemo, tremo, sentovento intorno al cuoreE"per I"amore che ho per teche mi fa superare mille tempesteE"per l"amore che ti doe per l"amore che vorreida questo mareE"per la vita che non c"eche mi fai naufragareinfondo al cuoreTutto questo ti avrae a te sembreratutto normaleFinehttp://music.baidu.com/song/9689808

concat()连接两个或更多的数组，并返回结果。join()把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。pop()删除并返回数组的最后一个元素push()向数组的末尾添加一个或更多元素，并返回新的长度。reverse()颠倒数组中元素的顺序。

a.push(x)只是把x的值push进去，如果要把变量名push进去，只能用字符串。例如：var a = "test";var b = [];b.push("a");提取a的值：alert(eval(b[0]));

【答案】：CArray对象即数组对象，在JavaScript中用于在单个变量中存储多个值，由JavaScript中的数组是弱类型，允许数组中含有不同类型的元素，数组元素甚至可以是对象或者其他数组。Array对象提供的主要方法包括：sort（ ）方法用于对数组元素进行排序；pop（ ）方法用于删除并返回数组的最后一个元素；splice（ ）方法用于插入、删除或替换数组中的元素；push（ ）方法用于向数组的末尾添加一个或多个元素，并返回新的长度。

parseInt将数字转化为整数parseFloat将数字转化为带小数的数字好像是这样

真想要的话，先把分给了，加我百度HI，我给你做个。。。。。。。。。

先使用查询语句 获得结果集，然后利用迭代器获得集合中的价格的和 ，然后除以天数就可以了

获取表单数据的时候使用的

作用：为了避免反复创建对象的开销，可以采用Singleton延迟创建技术，确保整个进程中只有一个对象，并且只有第一次调用的时候才会被创建出来。Helper helper = Helper.getInstance();helper.f1();

public class dd {public static void main(String[] args) {OperaNode op = new OperaNode();op.addToHead(1);op.addToHead(2);op.addToHead(3);op.addToHead(5);op.printAll();op.getMax();}}class Node {public int data;public Node next;public Node(){}public Node(int i) {data=i;next=null;}public Node(int i, Node n) {data = i;next = n;}}//链表类class OperaNode {public int max;public Node head, tail;public OperaNode() {head = tail = null;}// 判断链表是否为空public boolean isEntry() {if (head == null) {return true;} else {return false;}}// 在链表的头部添加数据public void addToHead(int l) {head = new Node(l, head);if (tail == null) {tail = head;}}public void printAll() {Node temp;for (temp = head; temp != null ; temp = temp.next) {System.out.println(temp.data);}}public void getMax(){Node temp =null;Node tmp =head;for (temp = head; temp != null ; temp = temp.next){if(tmp.data<temp.data){tmp.data=temp.data;}//head = head.next;}System.out.println(tmp.data);}}运行结果：53215

既然能用javax.出来。来自javax包。

这个包的作用是持久化的作用，具体的说就是在实体类中进行元数据标签的作用，是ORM框架中用到的。ORM框架可以通过这个元数据标签，使得实体类与数据库中的表建立映射关系。例如javax.persistence.Column标识实体类中的这个属性对应于数据库中的一个字段等等。这个好像不是对于hibernate使用的，而是open jpa使用，open jpa也是一种orm框架和hibernate类似。如果你想使用这个，在项目中导入geronimo-jpa_3.0_spec.jar这个jar就可以了，放到你的lib下。

持久化实例的，比如把一个类存储在数据库中，EJB的EntryBean用的就是它。

例1、用lambda表达式实现Runnable我开始使用Java 8时，首先做的就是使用lambda表达式替换匿名类，而实现Runnable接口是匿名类的最好示例。看一下Java 8之前的runnable实现方法，需要4行代码，而使用lambda表达式只需要一行代码。我们在这里做了什么呢？那就是用() -> {}代码块替代了整个匿名类。// Java 8之前：new Thread(new Runnable() {@Overridepublic void run() {System.out.println("Before Java8, too much code for too little to do");}}).start();//Java 8方式：new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();输出：too much code, for too little to doLambda expression rocks !!这个例子向我们展示了Java 8 lambda表达式的语法。你可以使用lambda写出如下代码：(params) -> expression(params) -> statement(params) -> { statements }例如，如果你的方法不对参数进行修改、重写，只是在控制台打印点东西的话，那么可以这样写：() -> System.out.println("Hello Lambda Expressions");如果你的方法接收两个参数，那么可以写成如下这样：(int even, int odd) -> even + odd顺便提一句，通常都会把lambda表达式内部变量的名字起得短一些。这样能使代码更简短，放在同一行。所以，在上述代码中，变量名选用a、b或者x、y会比even、odd要好。例2、使用Java 8 lambda表达式进行事件处理如果你用过Swing API编程，你就会记得怎样写事件监听代码。这又是一个旧版本简单匿名类的经典用例，但现在可以不这样了。你可以用lambda表达式写出更好的事件监听代码，如下所示：// Java 8之前：JButton show = new JButton("Show");show.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {System.out.println("Event handling without lambda expression is boring");}});// Java 8方式：show.addActionListener((e) -> {System.out.println("Light, Camera, Action !! Lambda expressions Rocks");});Java开发者经常使用匿名类的另一个地方是为 Collections.sort() 定制 Comparator。在Java 8中，你可以用更可读的lambda表达式换掉丑陋的匿名类。我把这个留做练习，应该不难，可以按照我在使用lambda表达式实现 Runnable 和 ActionListener 的过程中的套路来做。例3、使用lambda表达式对列表进行迭代

优点：1、代码更加简洁，效率高；2、减少匿名内部类的创建，节省资源；缺点：1、不熟悉Lambda表达式的语法的人，不太容易看得懂；2、虽然代码更加简洁，但可读性差，不利于维护；如有帮助请采纳(不懂请提问)，可以看我主页，欢迎来交流学习；

这个包的作用是持久化的作用，具体的说就是在实体类中进行元数据标签的作用，是ORM框架中用到的。ORM框架可以通过这个元数据标签，使得实体类与数据库中的表建立映射关系。例如javax.persistence.Column标识实体类中的这个属性对应于数据库中的一个字段等等。这个好像不是对于hibernate使用的，而是open jpa使用，open jpa也是一种orm框架和hibernate类似。如果你想使用这个，在项目中导入geronimo-jpa_3.0_spec.jar这个jar就可以了，放到你的lib下。希望帮助了你~~~

list.forEach(str -> {if (str.contains("a")) {System.out.println(str);} else {System.out.println("others");}});

lambda用来做低耦合的纯函数，抛异常就产生耦合。不做画蛇添足。要就在lambda中try...catch处理掉异常，要就不用lambda，用普通函数抛吧

这个包的作用是持久化的作用，具体的说就是在实体类中进行元数据标签的作用，是ORM框架中用到的。ORM框架可以通过这个元数据标签，使得实体类与数据库中的表建立映射关系。例如javax.persistence.Column标识实体类中的这个属性对应于数据库中的一个字段等等。这个好像不是对于hibernate使用的，而是open jpa使用，open jpa也是一种orm框架和hibernate类似。如果你想使用这个，在项目中导入geronimo-jpa_3.0_spec.jar这个jar就可以了，放到你的lib下。

随着编程语言生态系统的气候不断变化以及技术的革新，经历20余年的发展，Java逐渐演变成长为Java8。相比之前只是单纯的面向对象编程语言，Java8增加了很多新特性。Java 8对于程序员的主要好处在于它提供了更多的编程工具和概念，能以更为简洁、更易于维护的方式解决新的或现有的编程问题。在Java 8中有两个著名的改进：一个是Lambda表达式，一个是Stream。Lambda表达式是什么？Lambda表达式，也可称为闭包，它允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用Lambda表达式可以使代码变的更加简洁紧凑，Lambda表达式的语法格式：(parameters) -> expression或(parameters) ->{ statements; }Lambda表达式的重要特征:可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。可选的大括号：如果主体包含了一个语句，就不需要使用大括号。可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。使用Lambda表达式需要注意以下两点：Lambda表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。Lambda表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。Stream是什么？Stream就是一个流，它的主要作用就是对集合数据进行查找过滤等操作。Java 8中的 Stream是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作(bulk data operation)。对于基本数值型，目前有三种对应的包装类型Stream：IntStream、LongStream、DoubleStream。当然我们也可以用Stream<Integer>、Stream<Long> >、Stream<Double>，但是boxing和 unboxing会很耗时，所以特别为这三种基本数值型提供了对应的Stream。Java 8中还没有提供其它数值型Stream，因为这将导致扩增的内容较多。而常规的数值型聚合运算可以通过上面三种Stream进行。Stream上的操作分为两类：中间操作和结束操作。中间操作只是一种标记，只有结束操作才会触发实际计算。中间操作又可以分为无状态的(Stateless)和有状态的(Stateful)，无状态中间操作是指元素的处理不受前面元素的影响，而有状态的中间操作必须等到所有元素处理之后才知道最终结果，比如排序是有状态操作，在读取所有元素之前并不能确定排序结果。结束操作又可以分为短路操作和非短路操作，短路操作是指不用处理全部元素就可以返回结果，比如找到第一个满足条件的元素。之所以要进行如此精细的划分，是因为底层对每一种情况的处理方式不同。想要永远处于优势地位，就要不断的完善自身、更新技术。

Lambda 这个使用方便 呀。

为了支持函数式编程，Java 8引入了Lambda表达式.在Java 8中采用的是内部类来实现Lambda表达式.具体实现代码,可以通过debug看, 同时通过字节码查看工具及反编译工具来验证.自从lambda表达式成为Java语言的一部分之后，Java集合（Collections）API就面临着大幅变化。而JSR 355（规定了Java lambda表达式的标准）的正式启用更是使得Java集合API变的过时不堪。尽管我们可以从头实现一个新的集合框架（比如“Collection II”），但取代现有的集合框架是一项非常艰难的工作，因为集合接口渗透了Java生态系统的每个角落，将它们一一换成新类库需要相当长的时间。因此，我们决定采取演化的策略（而非推倒重来）以改进集合API： 为现有的接口（例如Collection，List和Stream）增加扩展方法；在类库中增加新的流（stream，即java.util.stream.Stream）抽象以便进行聚集（aggregation）操作；改造现有的类型使之可以提供流视图（stream view）； 改造现有的类型使之可以容易的使用新的编程模式，这样用户就不必抛弃使用以久的类库，例如ArrayList和HashMap（当然这并不是说集合API会常驻永存，毕竟集合API在设计之初并没有考虑到lambda表达式。我们可能会在未来的JDK中添加一个更现代的集合类库）。除了上面的改进，还有一项重要工作就是提供更加易用的并行（Parallelism）库。尽管Java平台已经对并行和并发提供了强有力的支持，然而开发者在实际工作（将串行代码并行化）中仍然会碰到很多问题。因此，我们希望Java类库能够既便于编写串行代码也便于编写并行代码，因此我们把编程的重点从具体执行细节（how computation should be formed）转移到抽象执行步骤（what computation should be perfomed）。

好像是Hibernate相关的

“Lambda 表达式”(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。我现在主要用来做一下循环啊，过滤啥的，语句少很方便。

可能有两个原因：1。Lambda表达式可以简化匿名函数的写法，减轻程序员负担。2。其他主流语言中有了这种特性，所以Java也要跟着引入。比如C＋＋2010标准就支持lambda表达式。

这个包的作用是持久化的作用，具体的说就是在实体类中进行元数据标签的作用，是ORM框架中用到的。ORM框架可以通过这个元数据标签，使得实体类与数据库中的表建立映射关系。例如javax.persistence.Column标识实体类中的这个属性对应于数据库中的一个字段等等。这个好像不是对于hibernate使用的，而是open jpa使用，open jpa也是一种orm框架和hibernate类似。如果你想使用这个，在项目中导入geronimo-jpa_3.0_spec.jar这个jar就可以了，放到你的lib下。希望帮助了你~~~

如图：按我的理解写的

可以，jdk要8就行

1、使用了spring的aop思想，实现了动态数据源的切换。2、spring的事务管理，是基于数据源的，所以如果要实现动态数据源切换，而且在同一个数据源中保证事务是起作用的话，就需要注意二者的顺序问题，即：在事物起作用之前就要把数据源切换回来。举一个例子：web开发常见是三层结构：controller、service、dao。一般事务都会在service层加的，如果使用spring的声明式事物管理，那么在调用service层代码之前，spring会通过aop的方式动态添加事务控制代码，所以如果要想保证事物是有效的，那么必须spring添加事务之前把数据源动态切换过来，也就是动态切换数据源的aop要至少在service上添加，而且要在spring声明式事物aop之前添加。最简单的方式是，把动态切换数据源的aop加到controller层，这样在controller层里面就可以确定下来数据源了。不过，这样有一个缺点就是，每一个controller绑定了一个数据源，不灵活。对于这种：一个请求，需要使用两个以上数据源中的数据完成的业务，就无法实现了。针对上面的这种问题，可以考虑把动态切换数据源的aop放到service层，但要注意一定要在事务aop之前来完成。这样，对于一个需要多个数据源数据的请求，我们只需要在controller里面注入多个service实现即可。但这种做法的问题在于，controller层里面会涉及到一些不必要的业务代码，例如：合并两个数据源中的list...针对上面的问题，可以再考虑一种方案，就是把事务控制到dao层，然后在service层里面动态切换数据源。

内部原因（1）功能代码编写考虑不全（2）测试用例需要改进或完善（3）部署到真实环境出现操作性错误外部因素（1）部署环境不同（2）若有配置文件，可能出现识别上的问题（3）真实环境数据过于庞大（4）若为WEB项目，可能有浏览器兼容问题

一般指的开发环境，测试环境，UAT环境；顾名思义：跟环境有关系，代码只是配置的环境地址和参数不同。

SORRY呀， 应该是SIT和UAT 吧, 好象不是SAT内部测试SIT :System Integration TestCase 根据用例描述测试每一个场景，优化系统性能，提交数据库性能excution plan给DBA review。对系统进行压力测试（必要情况下提交到APCC的压力测试组进行测试）。里程碑：完成内部测试报告和得到DBA的上线批准。用户测试UAT : User Acceptance Test用户根据用例描述测试每一个场景，反馈系统issue。开发人员基于issue对系统影响和对业务impact判断，适当的修正系统或记录业务需求，根据业务优先等级，集成进下一个演进阶段。 里程碑：UAT Sign off。用户签收当前系统功能。

System.out.println("i="+i+", j="+j);

u后面加上十六进制代码来表示Unicode字符。

接口不可以实例化，但是可以实例他的实现类。o2是CFace()的对象，也就是CFace()类型。

作用范围不一样啊

这是xml解析，去看dom4j的资料吧。

产生这个错误是因为:举例<bean:write name="xxx" property="stime"/>的时候，xxx这个对象找不到stime这个属性1、看看xxx中是否有这个属性2、看一下struts-config.xml中配置action-mapping里面的name值是否和上面的xxx匹配，注意大小写

我估计你在监听器中写增加监听器的方法！导致你弹出窗口的监听器按一次加一次，监听器太多了！最后你点击弹出按钮的时候，跳出好几个窗口，而且点一次，弹出窗口数量就会多一个！是不是啊？你给的代码太少，我看不出具体原因~~~~

class CCFrame extends JFrame { private JButton btn = new JButton("弹出新窗口"); public CCFrame() { setSize(500,300); setLocationRelativeTo(null); setVisible(true); setDefaultCloseOperation(DISPOSE_ON_CLOSE); setLayout(new FlowLayout()); add(btn); btn.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent arg0) { // 弹出一个新的Frame final JFrame f = new JFrame(); f.setTitle("这是新窗口"); f.setSize(300,200); f.setVisible(true); f.setLocationRelativeTo(null); f.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent arg0) { f.dispose(); } }); } }); } } 然后new CCFrame()就可以了。

它的作用是销毁程序中指定的图形界面资源，对数据资源不产生影响。

一楼的应该是有效的。但没有解决本质问题。问题出在你的GUI程序架构上。你的程序主类已经是JFrame子类了，那么它的实例就是一个JFrame，为什么还要再new一个JFrame作为程序界面呢？在main函数中，new你的主类，就是new了Frame，直接用主类此实例做程序界面即可！所以，init中的代码应该是这样： //JFrame frame = new JFrame("test");这行不要了 add (panel,BorderLayout.SOUTH); add (pgb,BorderLayout.CENTER); add (label,BorderLayout.NORTH); setBounds(450, 300, 350, 100);//设置窗体长和宽 setVisible (true);//显示窗体 setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);//关闭有效轻松搞定！

因为你没给按钮加监听

释放由此Window、其子组件及其拥有的所有子组件所使用的所有本机屏幕资源。即这些Component的资源将被破坏，它们使用的所有内存都将返回到操作系统，并将它们标记为不可显示。通过随后调用pack或show重新构造本机资源，可以再次显示Window及其子组件。重新创建的Window及其子组件的状态与释放Window时这些对象的状态一致（不考虑这些操作之间的其他更改）。

exit是程序结束，dispose只是窗口关闭

Java编程中的graphics中的dispose方法是 java.awt.Windows类的方法，它的作用是销毁程序中指定的图形界面资源，如果在使用了graphics获得windows一些图形资源，而不进行关闭的话，由于后期多人使用就会造成内存溢出的情况的，导致程序卡死。dispose方法类似java 连接数据库时使用conn.close方法，也是为了关闭数据库连接资源。

dispose是 java.awt.Windows类的方法，它的作用是销毁程序中指定的图形界面资源，对数据资源不产生影响，所以当我们在SWing或是AWT中的图形界面组件时如果调用它，组建内的数据对象不会消失，只有在这些数据资源其他地方没有再使用后才会由垃圾回收机制处理掉。关闭窗口 一般用 window.close() //貌似过时了现在用 window.setVisible(true) //true or false 控制窗体是否显示当然还可以用 window.hide() //仅仅是隐藏窗口

很繁琐~~~

1. 编写范例文档 public class TestNative{ private native static int Max(int a,int b); public static void main(String[] args) { System.out.println(Max(4,5)); } static { System.loadLibrary("VCdll"); } } 其中 LoadLibrary中的DLL文件名称可以随便定.只要做好的动态链接库改名成这个字符串就可以了.而native函数的来源就是该动态链接库. 2. 做好该步准备以后,用javac TestNative.java生成TestNative.class. 检验语法. 3. 语法检查通过以后,用javah TestNative生成TestNative.h的C++头文件. 4. 用VC++6.0创建dll文件: <1>msdev->new->project->win32 Dynamic-Link Library <2>Enter project name (e.g. VCdll) <3>choose "An empty DLL project"->finish <4>将3生成的TestNative.h和jdk下的jni.h和jni_md.h加入到工程中去 <5>Create a c++ file, implements the native method. as follows://TestNative.cpp#include "TestNative.h"JNIEXPORT jint JNICALL Java_TestNative_Max (JNIEnv * a, jclass b, jint x, jint y){ return x > y ? x : y;}备注: A 其中的jni.h通常在 jdkinclude 可以先拷贝到VC安装目录下的include目录下.一劳永逸,以后可以方便使用JNI技术. B 全部的数据类型需要考虑Java和VC的接口问题.用jint jstring 等. C 函数名称和自动生成的.h文件中规定的一致.命名规则是: Java_使用类_方法名 6. 全编译一下VC++工程. 如果没有出错,则此时生成动态链接库成功. 把动态链接库VCdll.dll拷贝到TestNative.java所在的目录上. 7.运行java TestNative. OK :

别人的已经有的东西，给你参考一下：1. 编写范例文档 public class TestNative{ private native static int Max(int a,int b); public static void main(String[] args) { System.out.println(Max(4,5)); } static { System.loadLibrary("VCdll"); } } 其中 LoadLibrary中的DLL文件名称可以随便定.只要做好的动态链接库改名成这个字符串就可以了.而native函数的来源就是该动态链接库. 2. 做好该步准备以后,用javac TestNative.java生成TestNative.class. 检验语法. 3. 语法检查通过以后,用javah TestNative生成TestNative.h的C++头文件. 4. 用VC++6.0创建dll文件: <1>msdev->new->project->win32 Dynamic-Link Library <2>Enter project name (e.g. VCdll) <3>choose "An empty DLL project"->finish <4>将3生成的TestNative.h和jdk下的jni.h和jni_md.h加入到工程中去 <5>Create a c++ file, implements the native method. as follows://TestNative.cpp#include "TestNative.h"JNIEXPORT jint JNICALL Java_TestNative_Max (JNIEnv * a, jclass b, jint x, jint y){ return x > y ? x : y;}备注: A 其中的jni.h通常在 jdkinclude 可以先拷贝到VC安装目录下的include目录下.一劳永逸,以后可以方便使用JNI技术. B 全部的数据类型需要考虑Java和VC的接口问题.用jint jstring 等. C 函数名称和自动生成的.h文件中规定的一致.命名规则是: Java_使用类_方法名 6. 全编译一下VC++工程. 如果没有出错,则此时生成动态链接库成功. 把动态链接库VCdll.dll拷贝到TestNative.java所在的目录上. 7.运行java TestNative. OK :-)参考资料：http://hi.baidu.com/dinguangx/blog/item/196560017e40e2031c95832f.html

当然不用重新生成.dll文件了，直接在java文件中声明并调用就可以了。当然了，下面的这个工作还是要做的：在JAVA程序中，首先需要在类中声明所调用的库名称，如下： static { System.loadLibrary(“goodluck”); }