java路径问题
ava中使用的路径，分为两种：绝对路径和相对路径。具体而言，又分为四种：
import java.io.*;
import java.util.jar.*;
public class JarRead {
public static void main (String args[])
throws IOException {
if (args.length != 2) {
System.out.println( "Please provide a JAR filename and file to read ");
System.exit(-1);
}
JarFile jarFile = new JarFile(args[0]);
JarEntry entry = jarFile.getJarEntry(args[1]);
InputStream input = jarFile.getInputStream(entry);
process(input);
jarFile.close();
}
private static void process(InputStream input)
throws IOException {
InputStreamReader isr =
new InputStreamReader(input);
BufferedReader reader = new BufferedReader(isr);
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
reader.close();
}
}
public JDomParse(){
3String xmlpath="library.xml";
4SAXBuilder builder=new SAXBuilder(false);
5try {
6Document doc=builder.build(xmlpath);
7Element books=doc.getRootElement();
8List booklist=books.getChildren("book");
9for (Iterator iter = booklist.iterator(); iter.hasNext();) {
10Element book = (Element) iter.next();
11String email=book.getAttributeValue("email");
12System.out.println(email);
13String name=book.getChildTextTrim("name");
14System.out.println(name);
15book.getChild("name").setText("alterrjzjh");
16
17}
18
19XMLOutputter outputter=new XMLOutputter();
20outputter.output(doc,new FileOutputStream(xmlpath));
21
22} catch (JDOMException e) {
23e.printStackTrace();
24} catch (IOException e) {
25e.printStackTrace();
26}
27}
28public static void main(String[] args) {
29new JDomParse();
30}
public static Document readDocument(InputStream inputStream)throws IOException
{
try{
SAXBuilder builder=new SAXBuilder(false);
Document doc=builder.build(inputStream);
return doc;
}catch(Exception ex){
ex.printStackTrace();
throw new IOException(ex.getMessage());
}
}
引用的类：
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
//下面是引用到JDOM中的类
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
（1）使用JDOM首先要指定使用什么解析器。如：
SAXBuilder builder=new SAXBuilder(false); 这表示使用的是默认的解析器
（2）得到Document，我们以后要进行的所有操作都是对这个Document操作的：
Document doc=builder.build(xmlpath);
（3）得到根元素：
Element books=doc.getRootElement();
在JDOM中所有的节点—OM中的概念）都是一个org.jdom.Element类，当然他的子节点也是一个org.jdom.Element类。
（4）得到元素（节点）的集合：
List booklist=books.getChildren("book");
这表示得到“books”元素的所在名称为“book”的元素，并把这些元素都放到一个List集合中
（5）轮循List集合
for (Iterator iter = booklist.iterator(); iter.hasNext();) {
Element book = (Element) iter.next();
｝
还有一种轮循方法是：
for(int i=0;I<booklist.size();I++){
Element book=(Element)booklist.get(i);
}
（6）取得元素的属性：
String email=book.getAttributeValue("email");
取得元素book的属性名为“email”的属性值。
（7）取得元素的子元素（为最低层元素）的值：
String name=book.getChildTextTrim("name");
注意的是，必须确定book元素的名为“name”的子元素只有一个。
（8）改变元素（为最低层元素）的值：
book.getChild("name").setText("alterrjzjh");
这只是对Document的修改，并没有在实际的XML文档中进行修改
（9）保存Document的修改到XML文件中：
XMLOutputter outputter=new XMLOutputter();
outputter.output(doc,new FileOutputStream(xmlpath));
我们先要有一个XMLOutputter类，再把已经修改了的Document保存进XML文档中。
到此。用JDOM解析和处理XML文档讲解完了，麻雀虽小，五脏俱全。现在已对JDOM有个整体上的概念了吧
readUTF() 和 writeUTF(String)
CLDC中还有两个方法跟字符编码有关系：DataInputStream中的readUTF()和DataOutputStream中的writeUTF(String)。根据两个方法的Java Doc，writeUTF(String)首先会向输出流中写入字符串编码成UTF8格式后的byte数组长度（2个字节），然后再将这个UTF8的byte数组写入。而readUTF()则是先从输入流中读取2个字节，组成一个short数值，再从输入流中读出这个数值长度的byte数据，再将这个byte数组解码成字符串。详细说明请参考DataInputStream和DataOutputStream的Java Document。
http://yyzjava.iteye.com/blog/1181552
GridBagLayout是所有AWT布局管理器当中最复杂的,同时他的功能也是最强大的.这种现象源于它所提供的众多的可配置选项,你几乎可以完全地 控制容器的布局方式.尽管复杂性很明显,只要理解了基本思想,就很容易使用GridBagLayout了.
GridBagLayout从它的名字中你也可以猜到,它同GridLayout一样,在容器中以网格形式来管理组件.但GridBagLayout功能要来得强大得多.
1、GridBagLayout管理的所有行和列都可以是大小不同的.
2、GridLayout把每个组件限制到一个单元格,而GridLayout并不这样:组件在容器中可以占据任意大小的矩形区域,
GridBagLayout通常由一个专用类来对他布局行为进行约束,该类叫GridBagConstraints.其中的所有成员都是public的, 因此要学好如何使用GridBagLayout首先要了解有那些约束变量,以及如何设置这些约束变量.
以下是GridBagConstraints的公有成员变量
public int anchor
public int fill
public gridheight
Public gridweight
public girdx
public gridy
public Insets insets
public int ipadx
public int ipady
public double weightx
public double weighty
看起来有很多约束需要进行设置,但事实上许多约束只需设置一次,并对多个组件重用,每次添加组件时只有少数的项需要修改.
下面是一个具有简单约束的GridBagLayout示例
public class GridBagLayoutExample2 extends JPanel {
public GridBagLayoutExample2() {
this.setLayout(new GridBagLayout());
this.setOpaque(true);
GridBagConstraints c = new GridBagConstraints();
JButton b = new JButton ("One"）;
c.gridx = 0 ;
c.gridy = 0;
c.gridwidth = 2;
c.gridheight = 1;
this.add(b,c);//button 1 added
c.gridy++;
b= new JButton("Two"）;
this.add(b,c);
c.gridx = 2;
c.gridy = 0;
c.gridwidth = 2;
c.gridheight = 2;
b = new JButton("Three"）;
this.add(b,c);
c.gridx = 0 ;
c.gridy = 2;
c.gridwidth = 4;
c.gridheight =1 ;
this.add(new JTextField(35),c);
}
public static void main(String[] args) {
JFrame f = new JFrame("GridBagLayout 2"）;
JPanel p = new GridBagLayoutExample2();
f.getContentPane().add(p);
f.pack();
f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
图表 1
上述示例首先生成了约束对象c , 并设置了它的属性gridx , gridy , gridwidth, girdheight四个属性,下面简要介绍这四个属性的作用
gridx, gridy 这个属性是用来描述组件在布局时应处于那个网格位置,即描述网格开始的位置
gridwidth,gridheigh这两个属性用来描述组件在布局中的所占的网格的个数,gridwidth描述了该组件在横向上所占网格的个数,gridheight描述了该组件在纵向上所占网格的个数.
你也可以通过GridBagConstraints的RELETIVE,和REMAINDER来进行指定,它的用法是:
当把gridx值设置为GridBagConstriants.RELETIVE时,在一个组件添加时,将被放置在前一个组件的右侧.同理,对gridy 值设置为GridBagConstraints.RELETIVE时,在添加组件时,将被放置在前一个组件的下方,(这是一种根据前一个组件而决定当前组 件的相对放置方式)
对gridweight和gridheight也可以应用GridBagConstraints的REMAINDER方式,创建的组件会从创建的起点位置 开始一直延伸到容器所能允许的限度为止.该功能使得你可以创建跨越某些行或列的组件,从而改变相应方向上组件的数目,即使其后在布局的其他地方添加额外的 组件也是如此.
你可以注意到图表1的buttonOne和buttonTwo上下紧靠,你可以通过设置GridBagConstraints成员Insets来调整它周围的空间大小,
new Insets(int top , int left , int bottom, int right)
c.insets = new Insets(4,4,4,4);
图表2
接下去要解决的一个问题是容器缩放时的行为.对于文本栏这个问题是最明显的,无论容器如何变形,它都保持同样的大小.文本区域应该总是跨越在容器的底部,但你肯定不希望在纵向缩放时,文本栏也纵向增长.
weightx和weighty成员就是用来控制在容器变形时,单元格本身如何缩放.这两个属性都是浮点数值,描述了每个单元格在拉伸时横向或纵向等到的分配比例.如对上例中的weightx设置
button one 0.4
button two 0.4
button three 0.6
text area 1.0
则在拉伸过程中,假设拉伸了10个象素,则button one横向得到10*0.4 = 4个象素
button three得到了剩余的6个象素.在拉伸过程中按钮one和按钮three以0.4:0.6的方式放大
为了放置纵向拉伸时,文本框的纵向扩展,你可以把weighty设置为0
图表3
图表4
你可能已经注意到,尽管我们已经将文本框的weight设置为1.0,但它并没有占据额外的可用的横向空间,即并没有在横向拉伸时始终占据整个底部行.
之 所以出现这个问题,是因为单元格和组件之间的区别还没有弄清楚,weightx和weighty值控制的是容器增长时单元格扩展的程度,但它们对各个单元 格中的组件并没有直接的效应.实际上,当窗口扩展时容器的所有单元格都增长了,包括文本框所在的一横行单元格.但文本栏根本没有增长.这是因为在所分配的 单元格内部,组件的增长是由GridBagConstraints对象的fill成员控制的,它可取下列值
GridBagConstraints.NONE 不增长
GridBagConstraints.HORIZONTAL 只横向增长
GridBagConstraints.VERTICAL 只纵向增长
GridBagConstraints.BOTH 双向增长
当你创建一个GridBagConstraints对象时,其fill值设置为NONE,因此在单元格增长时,单元格内部组件不会增长.
图表5
ipadx和ipady两个属性:
在GridBagLayout 对容器进行布局时,它把每个组件的最小尺寸作为如何分配空间的一个约束条件来考虑;如果一个按钮的最小尺寸是30象素宽,20象素高,而相关联的约束对象 中,ipadx为4,ipady为2,那么按钮的最小尺寸将会成为横向38象素,纵向24象素.
anchor属性:
当组件在横向或纵向上小于所分配到的单元格面积时,该字段会起作用.在这些情况下,anchor将决定组件如何在可用的空间中对齐.默认情况下,组件固定在单元格的中心,周围均匀分布多余空间.你也可以指定其他对齐方式:
GridBagConstraints.NORTH
GridBagConstraints.SOUTH
GridBagConstraints.NORTHWEST
GridBagConstraints.SOUTHWEST
GridBagConstraints.SOUTHEAST
GridBagConstraints.NORTHEAST
GridBagConstraints.EAST
GridBagConstraints.WEST
今天看见je上一帖，对于上亿数据求和的算法，采用多线程到底快还是慢，我认为需要按情况而定。
1.单核，无IO，网络等资源操作情况下
结果：多线程比单线程理论上要慢
原因：多线程启动线程需要消耗cpu资源，多线程只是把这一计算过程分片，在同一时刻只会有一个线程占有cpu，所以采用多线程不但在启动时耗费资源，在线程调度上同样也耗费时间。所以单线程比多线程理论上要快。
2.单核，有IO，网络等资源操作情况下
结果：多线程比单线程理论上要快
原因：如果这上亿数据需要从文件中或者网络的其它地方（数据库）获取，在IO和网络操作的时候，由于IO和网络操作比cpu慢的多，所以cpu等待io操作；多线程的时候，当一个线程io读取部分数据的时候，其它线程可以进行计算。而单线程需要等待文件读取完成后进行计算。所以理论上多线程要快。
3.多核，无IO，网络等资源操作情况下
结果：不确定
原因：在大部分操作系统上，一个进程的多个线程可以分配到多个cpu上并行处理所以多线程理论上比单线程快；在部分的操作系统上不支持一个进程的多个线程分配到多个cpu上并行处理，根据1的结果可以看出多线程理论上比单线程慢。
4.多核，有IO，网络等资源操作情况下
结果：多线程比单线程理论上要快
原因：如果操作系统支持一个进程的多个线程分配到多个cpu上并行处理，则多线程比单线程理论上要快。
如果操作系统不支持一个进程的多个线程分配到多个cpu上并行处理，则多线程比单线程理论上要快，根据2的结果得出。
拿je上高手们的一个例子：挖山洞，我扩展下。
单核，单线程，有IO：相当于从山的一侧进行挖掘工作，工作者需要挖5分钟，然后花费5分钟，用小车将土运出。
单核，多线程，有IO：相当于从山的一侧进行挖掘工作，工作者需要挖5分钟，然后花费5分钟，用小车将土运出，运土的时候，另一个工作者开始挖掘；
双核，单线程，有IO：相当于从山的两侧一个工作者进行挖掘工作，工作者需要挖5分钟，然后花费5分钟，用小车将土运出；
双核，多线程，有IO：相当于从山的两侧两个工作者进行挖掘工作，工作者需要挖5分钟，然后花费5分钟，用小车将土运出；
单核，单线程，无IO：相当于一个工作者从山的一侧进行挖掘工作。
单核，多线程，无IO：相当于两个工作者从山的一侧进行挖掘工作，一个挖会休息，另一个歇息。
双核，单线程，无IO：相当于从山的两侧一个工作者进行挖掘工作。
双核，多线程，无IO：相当于从山的两侧两个工作者进行挖掘工作。
当然有些工地只允许一个工作者工作。
例子虽然比较牵强，但也大致可以说出个理来。一年后在来分析下，看看能不能从更深的角度进行分析！
http://javapub.iteye.com/category/107508?show_full=true