2008年5月6日
以前只知道alt+/调出assist,后来发现可以所有字母都激活content assist(方法百度上都有,就不在这写了).用起来果然很爽.但是eclipse还是有些默认的设置不是很好,比如空格键和=号会把第一行的内容自动上屏,其实很多时候我就是想输一个空格或=号而已.这个在设置里面没办法设置.幸好eclipse是有插件机制的,可以通过修改插件的源码,然后导出成插件,再替换掉原来的插件来处理
1.先找到相关的插件
打开Plug-ins View找到插件org.eclipse.jface.text,右键点击,选择import as Source Project,导入完成后,在你的workspace就可以看到这个project了
2.修改代码
在
src/org/eclipse/jface/text/contentassist/CompletionProposalPopup.java文件中,找到这样一行代码
char triggers = t.getTriggerCharacter();
if(contains(triggers,key))
在那行if判断里面,eclipse会判断key(就是你按下的键)是否在triggers中,如果是,那就触发下面的第一行提示上屏的代码.所以我们要做的就是把空格和=号排除就可以了:
if(key!='='&&key!=0x20&&contains(triggers,key))
3.把修改好的org.eclipse.jface.text导出
右键点击你的workspace里的org.eclipse.jface.text,选择export-->Deployable plugins and fragments, next,destination 选择archive file,然后finish.你就可以在zip文件里看到生成好的jar ,用它替换掉eclipse/plugins里面的同名jar包,就可以了
Visio的图标很多,但是用来设计web程序的基本没有,在网上找到了这个,觉得还蛮好用的,共享一下
/Files/yes1983/GUUUI_Web_Prototyping_Tool_3.zip
摘要: 本文分析了Eclipse中多线程程序的实现，讨论了在Eclipse客户端程序开发中应用多线程的方法和要注意的问题，同时也讨论了多线程程序的一些调试和问题解决的方法。
阅读全文
转载自http://blog.csdn.net/shangboerds/archive/2010/01/27/5260783.aspx
CTE:
说起WITH 语句，除了那些第一次听说WITH语句的人，大部分人都觉得它是用来做递归查询的。其实那只是它的一个用途而已，它的本名正如我们标题写的那样，叫做：公共表表达式（Common Table Expression），从字面理解，大家觉得它是用来干嘛的呢？其实，它是用来定义临时集合的。啊？VALUES语句不是用来定义临时集合的吗？怎么WITH语句也用来定义临时集合呢？它们有什么区别呢？
VALUES语句是用明确的值来定义临时集合的，如下：
VALUES (1,2), (1,3),(2,1)
WITH语句是用查询(也就是select语句)来定义临时集合的，从这个角度讲，有点像视图，不过不是视图，大家千万别误解。如下：
CREATE TABLE USER (
NAME VARCHAR(20) NOT NULL,---姓名
SEX INTEGER,---性别（1、男 2、女）
BIRTHDAY DATE---生日
);
WITH TEST(NAME_TEST, BDAY_TEST) AS
(
SELECT NAME,BIRTHDAY FROM USER--语句1
)
SELECT NAME_TEST FROM TEST WHERE BDAY_TEST='1949-10-1';--语句2
下面我们来解释一下，首先语句1执行，它会产生一个有两列（NAME,BIRTHDAY）的结果集；接着，我们将这个结果集命名为test，并且将列名重命名为NAME_TEST, BDAY_TEST；最后我们执行语句2，从这个临时集合中找到生日是1949-10-1，也就是共和国的同龄人。
怎么样？如果你感觉不好理解，请仔细的分析一下上面的语句。下面我们举个VALUES语句和WITH语句结合使用的例子，如下：
WITH TEST(NAME_TEST, BDAY_TEST) AS
(
VALUES ('张三','1997-7-1'),('李四','1949-10-1')
)
SELECT NAME_TEST FROM TEST WHERE BDAY_TEST='1949-10-1'
从上面的介绍和WITH语句不为大多数人所熟悉可以猜测，WITH语句是为复杂的查询为设计的，的确是这样的，下面我们举个复杂的例子，想提高技术的朋友可千万不能错过。考虑下面的情况：
CREATE TABLE USER
(
NAME VARCHAR(20) NOT NULL,--姓名
DEGREE INTEGER NOT NULL,--学历(1、专科 2、本科 3、硕士 4、博士)
STARTWORKDATE date NOT NULL,--入职时间
SALARY1 FLOAT NOT NULL,--基本工资
SALARY2 FLOAT NOT NULL--奖金
);
假设现在让你查询一下那些 1、学历是硕士或博士 2、学历相同，入职年份也相同，但是工资（基本工资+奖金）却比相同条件员工的平均工资低的员工。（哈哈，可能是要涨工资），不知道你听明白问题没有？该怎么查询呢？我们是这样想的：
1、查询学历是硕士或博士的那些员工得到结果集1，如下：
SELECT NAME,DEGREE,YEAR(STARTWORKDATE) AS WORDDATE, SALARY1+SALARY2 AS SALARY FROM USER WHERE DEGREE IN (3,4)；
2、根据学历和入职年份分组，求平均工资 得到结果集2，如下：
SELECT DEGREE,YEAR(STARTWORKDATE) AS WORDDATE, AVG(SALARY1+SALARY2) AS AVG_SALARY
FROM USER WHERE DEGREE IN (3,4)
GROUP BY DEGREE,YEAR(STARTWORKDATE)
3、以学历和入职年份为条件 联合两个结果集，查找工资<平均工资 的员工，以下是完整的SQL：
WITH TEMP1(NAME,DEGREE,WORDDATE,SALARY) AS
(
SELECT NAME,DEGREE,YEAR(STARTWORKDATE) AS WORDDATE, SALARY1+SALARY2 AS SALARY FROM USER WHERE DEGREE IN (3,4)
),
TEMP2 (DEGREE,WORDDATE,AVG_SALARY) AS
(
SELECT DEGREE,YEAR(STARTWORKDATE) AS WORDDATE, AVG(SALARY1+SALARY2) AS AVG_SALARY
FROM USER WHERE DEGREE IN (3,4)
GROUP BY DEGREE,YEAR(STARTWORKDATE)
)
SELECT NAME FROM TEMP1, TEMP2 WHERE
TEMP1.DEGREE=TEMP2.DEGREE
AND TEMP1.WORDDATE=TEMP2.WORDDATE
AND SALARY<AVG_SALARY;
查询结果完全正确，但我们还有改善的空间，在查询结果集2的时候，我们是从user表中取得数据的。其实此时结果集1已经查询出来了，我们完全可以从结果集1中通过分组得到结果集2，而不用从uer表中得到结果集2，比较上面和下面的语句你就可以知道我说的是什么意思了！
WITH TEMP1(NAME,DEGREE,WORDDATE,SALARY) AS
(
SELECT NAME,DEGREE,YEAR(STARTWORKDATE) AS WORDDATE, SALARY1+SALARY2 AS SALARY FROM USER WHERE DEGREE IN (3,4)
),
TEMP2 (DEGREE,WORDDATE,AVG_SALARY) AS
(
SELECT DEGREE,WORDDATE, AVG(SALARY) AS AVG_SALARY
FROM TEMP1
GROUP BY DEGREE,WORDDATE
)
SELECT NAME FROM TEMP1, TEMP2 WHERE
TEMP1.DEGREE=TEMP2.DEGREE
AND TEMP1.WORDDATE=TEMP2.WORDDATE
AND SALARY<AVG_SALARY;
可能有些朋友会说，我不用WITH语句也可以查出来，的确是这样，如下：
SELECT U.NAME FROM USER AS U,
(
SELECT DEGREE,YEAR(STARTWORKDATE) AS WORDDATE, AVG(SALARY1+SALARY2) AS AVG_SALARY
FROM USER WHERE DEGREE IN (3,4)
GROUP BY DEGREE,YEAR(STARTWORKDATE)
) AS G
WHERE U.DEGREE=G.DEGREE
AND YEAR(U.STARTWORKDATE)=G.WORDDATE
AND (SALARY1+SALARY2)<G.AVG_SALARY;
那使用WITH 和不使用 WITH，这两种写法有什么区别呢？一般情况下这两种写法在性能上不会有太大差异，但是，
1、当USER表的记录很多
2、硕士或博士（DEGREE IN (3,4)）在USER表中的比例很少
当满足以上条件时，这两种写法在性能的差异将会显现出来，为什么呢？因为不使用WITH写法的语句访问了2次USER表，如果DEGREE 字段又没有索引，性能差异将会非常明显。
当你看到这时，如果很好的理解了上面的内容，我相信你会对WITH语句有了一定的体会。然而WITH语句能做的还不止这些，下面给大家介绍一下，如何用WITH语句做递归查询。递归查询的一个典型的例子是对树状结构的表进行查询，考虑如下的情况：
论坛首页
--数据库开发
----DB2
------DB2 文章1
--------DB2 文章1 的评论1
--------DB2 文章1 的评论2
------DB2 文章2
----Oracle
--Java技术
以上是一个论坛的典型例子，下面我们新建一个表来存储以上信息。
CREATE TABLE BBS
(
PARENTID INTEGER NOT NULL,
ID INTEGER NOT NULL,
NAME VARCHAR(200) NOT NULL---板块、文章、评论等。
);
insert into bbs (PARENTID,ID,NAME) values
(0,0,'论坛首页'),
(0,1,'数据库开发'),
(1,11,'DB2'),
(11,111,'DB2 文章1'),
(111,1111,'DB2 文章1 的评论1'),
(111,1112,'DB2 文章1 的评论2'),
(11,112,'DB2 文章2'),
(1,12,'Oracle'),
(0,2,'Java技术');
现在万事兼备了，我们开始查询吧。假设现在让你查询一下‘DB2 文章1’的所有评论，有人说，这还不简单，如下这样就可以了。
SELECT * FROM BBS WHERE PARENTID=(SELECT ID FROM BBS WHERE NAME='DB2');
答案完全正确。那么，现在让你查询一下DB2的所有文章及评论，怎么办？传统的方法就很难查询了，这时候递归查询就派上用场了，如下：
WITH TEMP(PARENTID,ID,NAME) AS
(
SELECT PARENTID,ID,NAME FROM BBS WHERE NAME='DB2'---语句1
UNION ALL---语句2
SELECT B.PARENTID,B.ID,B.NAME FROM BBS AS B, TEMP AS T WHERE B.PARENTID=T.ID---语句3
)
SELECT NAME FROM TEMP;---语句4
运行后，我们发现，结果完全正确，那它到底是怎么运行的呢？下面我们详细讲解一下。
1、首先，语句1将会执行，它只执行一次，作为循环的起点。得到结果集：DB2
2、接着，将循环执行语句3，这里我们有必要详细介绍一下。
首先语句3的意图是什么呢？说白了，它就是查找语句1产生结果集（DB2）的下一级，那么在目录树中DB2的下一级是什么呢？是‘DB2 文章1’和‘DB2 文章2’，并且把查询到的结果集作为下一次循环的起点，然后查询它们的下一级，直到没有下一级为止。
怎么样？还没明白？哈哈，不要紧，我们一步一步来：
首先，语句1产生结果集：DB2，作为循环的起点，把它和BBS表关联来查找它的下一级，查询后的结果为：‘DB2 文章1’和‘DB2 文章2’
接着，把上次的查询结果（也就是‘DB2 文章1’和‘DB2 文章2’）和BBS表关联来查找它们的下一级，查询后的结果为：‘DB2 文章1 的评论1’ 和 ‘DB2 文章1 的评论2’。
然后，在把上次的查询结果（也就是‘DB2 文章1 的评论1’ 和 ‘DB2 文章1 的评论2’）和BBS表关联来查找它们的下一级，此时，没有结果返回，循环结束。
3、第三，将执行语句2，将所有的结果集放在一起，最终得到temp结果集。
4、最后，我们通过语句4 从temp临时集合中得到我们期望的查询结果。
怎么样，这回理解了吧，如果还没有理解，那么我也无能为力了。需要特别提醒的是
1、一定要注意语句3的关联条件，否则很容易就写成死循环了。
2、语句2必须是UNION ALL
最后请大家猜想一下，把语句1的where子句去掉，将会产生什么样的结果呢？
NTE:
SELECT * FROM <TABLE-NAME>;
看到上面的语句了吗？这是我们在熟悉不过的一条语句，我们中的大多人学习SQL正是从这条语句开始的。所以大多数人认为FROM语句后只能接一个表或视图（或者压根就没多想），有这种想法的人我非常能理解，因为我曾经也是这其中的一员。其实FROM后面可以接任何集合（表）。说到这，关于集合和表，我特别想多少几句。SQL的理论基础是数学中的集合理论，所以SQL关注的就是如何对集合进行操作，基于以上原因，我特别喜欢名词 集合，而不喜欢说表。不过，大家如果不习惯，也可以把集合和表当一个意思来理解，因为我们不是搞理论研究工作的，没必要深究他们之间的细微差别。说了这么多，我们还是赶快来看个例子吧。
---建表
CREATE TABLE USER
(
NAME VARCHAR(20) NOT NULL,---姓名
BIRTHDAY DATE---生日
);
---例子1
SELECT * FROM
(
SELECT * FROM USER
) AS TEMP1;
---例子2
SELECT NAME,BIRTHDAY FROM
(
SELECT NAME,BIRTHDAY FROM USER
) AS TEMP1;
---例子3
SELECT TEMP1.NAME,TEMP1.BIRTHDAY FROM
(
SELECT NAME,BIRTHDAY FROM USER
) AS TEMP1;
---例子4
SELECT N,B FROM
(
SELECT NAME,BIRTHDAY FROM USER
) AS TEMP1(N,B);
---例子5
SELECT AAA.A,AAA.B,XXX.X,XXX.Y FROM
(
SELECT NAME,BIRTHDAY FROM USER
) AS AAA(A,B),--集合1
(
SELECT NAME,BIRTHDAY FROM USER
) AS XXX(X,Y)--集合2
WHERE AAA.A=XXX.X AND AAA.B=XXX.Y--关联两个集合
看到上面的例子5了吗？我们可以给临时集合命名，还可以给重命名临时集合的列名，还可以关联两个临时集合，总之，操作临时集合和操作表没有区别。
Temporary table
临时表（TEMPORARY TABLE）通常应用在需要定义临时集合的场合。但是，在大部分需要临时集合的时候，我们根本就不需要定义临时表。当我们在一条SQL语句中只使用一次临时集合时，我们可以使用嵌套表表达式来定义临时集合；当我们在一条SQL语句中需要多次使用同一临时集合时，我们可以使用公共表表达式；只有当我们在一个工作单元中的多条SQL语句中使用同一临时集合时，我们才需要定义临时表。
可以通过以下三种方式定义临时表：
方法1：
DECLARE GLOBAL TEMPORARY TABLE SESSION.EMP
(
NAME VARCHAR(10),---姓名
DEPT SMALLINT,---部门
SALARY DEC(7,2)---工资
)
ON COMMIT DELETE ROWS;
方法2：
DECLARE GLOBAL TEMPORARY TABLE session.emp
LIKE staff INCLUDING COLUMN DEFAULTS
WITH REPLACE
ON COMMIT PRESERVE ROWS;
方法3：
DECLARE GLOBAL TEMPORARY TABLE session.emp AS
(
SELECT * FROM staff WHERE <condition>
)
DEFINITION ONLY
WITH REPLACE;
定义了临时表后，我们可以像使用普通表一样使用临时表。临时表只对定义它的用户有效，不同用户可以在同一时间定义同名的临时表，他们之间互不影响。临时表的生命周期是SESSION，当SESSION关闭时，临时表将自动删除，这也是临时表的模式名只能为SESSION的原因。此外，我们还可以给临时表定义索引。更多细节请参考DB2 信息中心。
Eclipse的扩展机制是其一个重要特色,但随着Eclipse功能越做越强,插件越来越多,你会发现GUI上的图标越来越多,Menu,toolbar,context menu都被占满了,其实很多item并不是我们需要的,但是contribute这些item的插件我们是需要的,那怎么去掉它们扩展的那些菜单项呢?
1.在Plugin.xml中定制
这是最简单的办法,很多时候我们自己想写代码来去掉一些菜单项,但效果并不好.所以能在Plugin.xml中定制的,我们就 尽量写在plugin.xml里面.下面举一个右键菜单的例子:
扩展右键菜单需要扩展org.eclipse.ui.popupMenus扩展点,我们一般都在它下面new一个action,但这个action扩展之后不管在 任何界面都会出现,如果我们想在某些条件下隐藏掉它该怎么办?仔细观察下org.eclipse.ui.popupMenus扩展点,其实我们还可以新建objectContribution扩展
<extension
point="org.eclipse.ui.popupMenus">
<objectContribution
id="my.example.objectContribution"
nameFilter="*example*"
objectClass="java.io.File">
<action
class="my.example.MyAction"
id="my.example.MyAction"
label="Exe"
menubarPath="additional">
</action>
</objectContribution>
</extension>
objectContribution里面也包含一个action,但这个action在popupmenu里出现是有条件的:我们给它定义了一个nameFilter, 只有当selection()的path中包含了"example"才会显示,否则这个action是不会出现在 popupmenu里的.这里的selection假设选中的是一个File,如果选中的是你自己写的类,那namefilter会在你的类的toString方法里面找keyword.
2.使用Eclipse的Activities扩展
plugin.xml并不能解决所有问题,当我们实在没有办法在plugin.xml中限制某些extension的出现的时候,可以考虑使用Eclipse的Activities.Activities的官方定义大家可以google一下eclipse的help.我个人的理解就是它可以和perspective一样控制UI的显示,但是Perspective设计的太易于扩展了,假如Plugin A在perspective上扩展了一个UI,那么Plugin B在每次进入这个perspective的时候就一定可以看得见它,而且在Eclipse的扩展机制下,Plugin B是没有权利去删了Plugin A的contribution的(Eclipse的ExtensionRegistry倒是提供了一个removeExtension方法,但运行的时候会报错).在这样的情况下,Activities的价值就体现出来了,你只要给它一个Extension的id,它就可以帮你把这个Extension disable掉.例如:
<extension
point="org.eclipse.ui.activities">
<activity
id="my.example.activity"
name="WizardActivity">
</activity>
<activityPatternBinding
activityId="my.example.activity"
pattern="my\.example/mywizard">
</activityPatternBinding>
</extension>
比较重要的是activityPatternBinding中的pattern属性,它是由plugin id + "/" + local-id组成.比如在插件my.example中扩展了 org.eclipse.ui.newWizards,id是mywizard,那么上面这个activityPatternBinding就会disable掉my.example的mywizard扩展,你在 GUI中就看不见这个wizard了.pattern是支持正则表达式的,所以如果有"."的话需要用转义字符\.注意,这里的disable的意思并不是说我把mywizard这个扩展删掉了,而是屏蔽了它,mywizard仍然在 ExtensionRegistry中.
3.用代码来动态控制UI
方法2只是隐藏掉一些扩展,但是有一些需求并不是简单的隐藏就可以了,我最近碰到的一个需求就是:有一个flag,只有当flag==1的时候扩展是可见的,否则是不可见的,需要disable这个扩展.这时就必须要加一些代码才能实现了,还是以方法2中的mywizard为例:
IWorkbenchActivitySupport workbenchActivitySupport = PlatformUI.getWorkbench().getActivitySupport();
IActivityManager activityManager = workbenchActivitySupport.getActivityManager();
Set enabledActivityIds = new HashSet(activityManager.getEnabledActivityIds());
if(flag==1)
{
if (enabledActivityIds.add("my.example.activity"))
workbenchActivitySupport.setEnabledActivityIds(enabledActivityIds);
}
else{
if(enabledActivityIds.remove("my.example.activity"))
workbenchActivitySupport.setEnabledActivityIds(enabledActivityIds);
}
Activities可以是enable或者disable的,当你在plugin.xml中定义好了一个Activity,缺省它是disable的,就是说activityPatternBinding 匹配的扩展是会被disable的,但你也可以把Activities设成enable的(在plugin.xml或者用代码都可以设置),它匹配的扩展是可以正常使用的.
在上面的code sample中,我们通过activityManager.getEnabledActivityIds()得到所有enable的Activities.如果flag==1,那my.example.activity 也应该被加入到enable Activities中,这样mywizard就可以显示在界面上,反之,就要在enable Activities中remove掉my.example.activity,它就变成
disable,会把mywizard隐藏.
摘要: Access Path
1.并不是用index就一定快.有时候一个表只有很少的records,那么你直接scan这个表,比你先读index,再访问表要快.
2.不过大多数情况下还是用index快一些(要不然这个技术就没有意义了).DB2中index的应用需要两个前提条件:
阅读全文
TreeViewer的setSelection方法使用后，会在树上选中并展开方法参数中对应的节点.但是有时候你发现它只能选中第一级节点,下面的子节点没有办法选中.其实这个方法是没有问题的,它的大概实现算法是:先找到某一个子节点,然后找到它的父节点,把父节点展开,然后又找父节点的父节点,做同样的操作,直到根节点为止,这样你才能看到选中的子节点.所以父节点如果为null,那肯定你是看不到子节点了.而我们很多人在实现ITreeContentProvide的接口的时候,是不实现getParent方法的,因为只要实现了getChildren方法就可以看见一棵树了.包括陈刚的<Eclipse从入门到精通>也是这样.所以在实现treeViewer的时候,最好还是实现getparent方法.其实也不麻烦,在添加一个child的时候,加一句setparent(this)就可以了
最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中 write(char[] ch,int off,int
length)，flush()和close()方法为抽象方法，Reader中read(char[] ch,int off,int length)和close()方法是抽象方法。子类应该分别实现他们。
当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader，
它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。当使用FileReader读取文件
的时候。
FileReader fr = new FileReader("ming.txt");
int ch = 0;
while((ch = fr.read())!=-1 )
{
System.out.print((char)ch);
}
其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用
InputStreamReader来读取文件的时候
while((ch = isr.read())!=-1)
{
System.out.print((char)ch);
}
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率
我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data = null;
while((data = br.readLine())!=null)
{
System.out.println(data);
}
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先
放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：
FileWriter fw = new FileWriter("hello.txt");
String s = "hello world";
fw.write(s,0,s.length());
fw.flush();
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt"));
osw.write(s,0,s.length());
osw.flush();
PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
pw.println(s);
不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。
import java.io.*;
public class TestFile2
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("ming.txt");
char[] buffer = new char[1024];
int ch = 0;
while((ch = fr.read())!=-1 )
{
System.out.print((char)ch);
}
InputStreamReader isr = new InputStreamReader(new FileInputStream("ming.txt"));
while((ch = isr.read())!=-1)
{
System.out.print((char)ch);
}
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data = null;
while((data = br.readLine())!=null)
{
System.out.println(data);
}
FileWriter fw = new FileWriter("hello.txt");
String s = "hello world";
fw.write(s,0,s.length());
fw.flush();
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt"));
osw.write(s,0,s.length());
osw.flush();
PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
pw.println(s);
fr.close();
isr.close();
br.close();
fw.close();
osw.close();
pw.close();
}
}
java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
public class ReadFromFile {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
* @param fileName 文件的名
*/
public static void readFileByBytes(String fileName){
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
// 一次读一个字节
in = new FileInputStream(file);
int tempbyte;
while((tempbyte=in.read()) != -1){
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
try {
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
//一次读多个字节
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, byteread);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null){
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
* @param fileName 文件名
*/
public static void readFileByChars(String fileName){
File file = new File(fileName);
Reader reader = null;
try {
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
// 一次读一个字符
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
while ((tempchar = reader.read()) != -1){
//对于windows下，rn这两个字符在一起时，表示一个换行。
//但如果这两个字符分开显示时，会换两次行。
//因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
if (((char)tempchar) != 'r'){
System.out.print((char)tempchar);
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println("以字符为单位读取文件内容，一次读多个字节：");
//一次读多个字符
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
//读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars))!=-1){
//同样屏蔽掉r不显示
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
System.out.print(tempchars);
}else{
for (int i=0; i<charread; i++){
if(tempchars[i] == 'r'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}
} catch (Exception e1) {
e1.printStackTrace();
}finally {
if (reader != null){
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
* @param fileName 文件名
*/
public static void readFileByLines(String fileName){
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
//一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null){
//显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null){
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 随机读取文件内容
* @param fileName 文件名
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile = null;
try {
System.out.println("随机读取一段文件内容：");
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, "r");
// 文件长度，字节数
long fileLength = randomFile.length();
// 读文件的起始位置
int beginIndex = (fileLength > 4) ? 4 : 0;
//将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[10];
int byteread = 0;
//一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
//将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1){
System.out.write(bytes, 0, byteread);
}
} catch (IOException e){
e.printStackTrace();
} finally {
if (randomFile != null){
try {
randomFile.close();
} catch (IOException e1) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
* @param in
*/
private static void showAvailableBytes(InputStream in){
try {
System.out.println("当前字节输入流中的字节数为:" + in.available());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
二、将内容追加到文件尾部
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 将内容追加到文件尾部
*/
public class AppendToFile {
/**
* A方法追加文件：使用RandomAccessFile
* @param fileName 文件名
* @param content 追加的内容
*/
public static void appendMethodA(String fileName,
String content){
try {
// 打开一个随机访问文件流，按读写方式
RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
// 文件长度，字节数
long fileLength = randomFile.length();
//将写文件指针移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} catch (IOException e){
e.printStackTrace();
}
}
/**
* B方法追加文件：使用FileWriter
* @param fileName
* @param content
*/
public static void appendMethodB(String fileName, String content){
try {
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer = new FileWriter(fileName, true);
writer.write(content);
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
String content = "new append!";
//按方法A追加文件
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName, "append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
//按方法B追加文件
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName, "append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
}
}
1.有的时候在project的java build path中定义好了一些jar包依赖,但是project在运行的时候仍然报NoClassDef的错误.这是因为project的MANIFEST.MF文件没有更新.手动在MANIFEST.MF加上那些jar包就可以了.
2.Plugin A 依赖 Plugin B.B也把相应的package export出来了,但是A还是找不到B里面定义的类.修改A的MANIFEST.MF文件,在dependence tab里去掉Plugin B,再添加B.此时发现有5,6个同样的Plugin B出现在选择plugin的list中.cancel 掉该对话框,然后重启eclipse,在A的dependence里面重新加上B,问题解决.
3.当我们通过在plugin.xml中用extension的方式定义action的时候,你会发现你定义的actionset和action在GUI出现的顺序不是你可以控制的,就是说同一个actionset下的多个action不是按你定义的先后顺序出现在程序的界面上的,这样对action进行排序呢?其实仔细观察一下,你会发现action在GUI出现的顺序是和你定义action的顺序相反的,比如你先后定义了3个action A,B,C,那么你就会在GUI上看见action的顺序是C,B,A.如果你定义了多个actionset,你会发现这个规律不适用与actionset,actionset在界面上出现的顺序其实是和它的id的排序相反的.比如你定义了三个actionset,它们的id分别是:seta,setb,setc,你会发现GUI上出现的顺序是setc,setb,seta
4.双击激活TreeViewer的celleditor
JFace的Viewer都有单元格编辑功能,但是celleditor默认的实现是单击激活editor,双击选中item.如果需要改成单击选中item,双击激活editor呢?Eclipse的官网上好像也有人问到这个问题,不过目前好像是开了一个bug,期待eclipse的下个版本解决这个问题.但最近找到了一个用SWT来解决这个问题的方法:
Tree tree=treeViewer.getTree();
final TreeEditor editor = new TreeEditor(tree);
editor.horizontalAlignment = SWT.LEFT;
editor.grabHorizontal = true;
// Use a mouse listener, not a selection listener, because you're
// interested
// in the selected column as well as row
tree.addMouseListener(new MouseAdapter() {
public void mouseDoubleClick(MouseEvent event) {
final TreeItem item = tree.getSelection()[0];
// Create a text field to do the editing
final Text text = new Text(tree, SWT.NONE);
text.setText(item.getText());
text.selectAll();
text.setFocus();
text.addFocusListener(new FocusAdapter() {
public void focusLost(FocusEvent event) {
text.dispose();
}
});
// Set the text field into the editor
editor.setEditor(text, item);
}
});
由于Eclipse的易扩展性,理论上可以有无数个Action运行在一个RCP 程序中,但是快捷键是有限的,尤其是一些常用的,像Ctrl+C,Ctrl+S之类的普通用户能记得住的就那么几个,万一你自定义的Action的快捷键和Eclipse默认的发生了冲突怎么办?比如Eclipse默认Ctrl+S是Save的快捷键,但是你又自定义了一个SaveAction,希望用户按下Ctrl+S之后执行的是自己的SaveAction的run方法.
一般给Action绑定快捷键的方法是自定义binding和command,然后在action中指定definition id为command的id.如下:
<extension
point="org.eclipse.ui.bindings">
<key
commandId="myplugin.actions.save"
contextId="org.eclipse.ui.contexts.window"
schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
sequence="CTRL+S">
</key>
</extension>
<extension
point="org.eclipse.ui.commands">
<command
id="myplugin.actions.save"
name="Save">
</command>
</extension>
这样的方法一般是不会有冲突的,但是像我们上面提到的情况,如果你自定义一个binding,它的key sequence是Ctrl+S,那就会有问题.由于org.eclipse.ui插件已经提供了一个Ctrl+S的快捷键,所以系统中会有两个Ctrl+S,这样Eclipse会在右下角pop up一个assist dialog,让你从两个Action中选择一个,这样可能会造成一些用户使用上的不习惯.
解决办法:
1.直接改快捷键.
这个最简单了,比如把你自己的save定义成Alt+S.但是这个方法也是最不好的方法,因为很多用户并不知道Alt+S在你的程序里面就是save.
2.修改自定义action的definition id
我们刚才说过,action的definition id绑定着一个command,而command又对应着一个binding,Eclipse通过这样的方式实现action和快捷键的绑定.我们再来看看Eclipse定义的command和key binding(摘自org.eclipse.ui的plugin.xml):
<command
name="%command.save.name"
description="%command.save.description"
categoryId="org.eclipse.ui.category.file"
id="org.eclipse.ui.file.save" />
<key
commandId="org.eclipse.ui.file.save"
sequence="M1+S"
schemeId="org.eclipse.ui.defaultAcceleratorConfiguration" />
<key
Eclipse的Save Action把definition id指定为org.eclipse.ui.file.save,然后它就和上面的command进行了绑定,而这个command对应的key就是"M1+S"(Ctrl + S),这样就实现了快捷键绑定.如果我们也把自定义的Save Action的definition id指定为org.eclipse.ui.file.save,是不是就可以达到目的呢?答案是肯定的.
Eclipse中的Action存在着一个类似"优先级"的概念(具体实现是通过action handler).越"具体"的action,优先级越高.Eclipse的Save Action明显是一个global的action,(同样的global action还有copy, cut,undo,redo等等).而我们自定义的action一般是实现了IWorkbenchWindowActionDelegate接口的,就是说,它是contribute to workbench window的,它是一个workbench action,它的优先级就高于任何global action.同理,如果你定义一个editor action或者view action,由于它比workbench还"具体"(workbench可以包含多个editor或view,workbench action对这些editor或view都是有效的;而editor action只对某个具体的editor有效),所以editor action的优先级就高于workbench action.这样,如果自定义的action和eclipse缺省的action都绑定到同一个command,那么eclipse runtim最后会选择自定义的action来执行.
3.终极解决大法:自定义schema
Eclipse 有一个default的快捷键schema文件:org.eclipse.ui.defaultAcceleratorConfiguration.它存储着Eclipse所有的快捷键.如果你自定义一个自己的schema文件,并把它设成当前使用的schema文件,那么Eclipse就会调用自定义的schema文件.(新的schema文件可以在org.eclipse.ui.bindings扩展点中定义,请注意,在定义新schema的时候由一个parentID属性,如果你定义了它,新的schema会像类继承一样把parent schema里面的key binding全继承下来.如果不定义,则是一个全新的schema)
假定我们已经有了一个新的schema文件,id是myplugin.schema.然后我们在org.eclipse.ui.bindings下定义一个key:
<key
commandId="myplugin.actions.save"
contextId="org.eclipse.ui.contexts.window"
schemaId="myplugin.schema"
sequence="CTRL+S">
</key>
我们已经把schemaId换成了myplugin.schema,表示我们把CTRL+S加到了myplugin.schema中,然后把新建的schema文件在product配置文件plugin_customization.ini中设置成当前的key schema文件:
org.eclipse.ui/KEY_CONFIGURATION_ID=myplugin.schema
这种方法虽然麻烦了一点,但却可以治标又治本.而且由于可以指定parent schema,我们完全可以把org.eclipse.ui.defaultAcceleratorConfiguration作为parent schema,继承它全部的快捷键配置,只定制几个会产生冲突的快捷键即可
gef中经常会有很多连线,这些连线如何和每个node连接,允不允许交叉等等都是用router来控制的.网上有篇文章对这个做了一些介绍:
http://www-128.ibm.com/developerworks/cn/opensource/os-ecl-gef/part2/
我现在做的这个项目需要在两个node之间同时存在多根线,如果不使用router的话就只能看见一根,在diagram的 figure里面set一个FanRouter作为缺省的router就可以解决这个问题.两个node之间如果存在多根连线的话,FanRouter会把它们分布成扇形,每根连线都可以看见.但是FanRouter好像只能在diagram的figure里面设置,如果每根connection你都设置成FanRouter,反而不会启效果,这可能跟它的handlecollision方法的算法有关.
但是设置成FanRouter之后有一个问题:我的项目中还有那种自连接的connection(该connection的source和target是同一个node),原先我是把这种connection的router设置为bendconnectionrouter,但是后来设置了FanRouter之后BendConnectionRouter好像就失效了,不管你的connection上面有多少个bendpoint都看不出来效果.
后来终于找到了让这两张router和平共处的办法,只要加一行:fanRouter.setNextRouter(new BendPointConnectionRouter());setNextRouter这个方法有点怪,按照字面的理解,应该是fanrouter的下一个router,按理说应该是先用fanrouter来layout 连线,然后再使用BendPointConnectionRouter来layout 连线,但是它实际上是先用BendPointConnectionRouter来layout 连线,然后再使用fanRouter.
GEF中自带有Directeditrequest,所以实现Directedit还是比较容易的,八进制的gef例子里面就有实现.但我在给directedit加上content assist的时候却发现由一个小bug不太好弄,费了两天才搞定,现在先记下来,以供参考
directedit是通过一个text celleditor来实现编辑功能的,所以可以在directeditmanager类里面的initCellEditor方法里面加上ContentAssistHandler来实现auto complete.但是加上去之后却发现有一个问题:不支持用鼠标来选择proposal.只能用键盘上的上下箭头来选择.虽然也可以用,但是终究不是那么的人性化.
为了修复这个bug,走了不少的弯路,一开始以为是contentassist的问题,因为它是deprecated,所以换了3.3里面的assist api,发现还是不行.后来才知道是因为celleditor有一个focus listener,当用户点击proposals 来选择一行的时候,celleditor的focus就lost了,就会调用focusLost方法,导致directedit编辑失败.所以我重写了celleditor的focusLost方法,把它设成当focus在contentassist的popup dialog就什么都不干,否则调用父类的focusLost方法.理论上是一个好的解决方法,但是contentassist的hasPopupFocus居然一直都返回false,这个方法也失败了.
最后,在bug.eclipse.org上面有人提到GMF里面的TextDirectEditManager是可以做到用鼠标选择proposal的,于是又去看gmf的这个类,它也是继承自DirectEditManager,不过它消除这个bug不是在listener上作文章,而是在commit方法里面,在这个方法里面判断popup dialog是否是active的,如果是的话则给celleditor加上deactive lock,不允许它deactive,这样来实现用鼠标选择proposal.
下面是TextDirectEditManager的方法commit里面的部分代码:
Shell activeShell = Display.getCurrent().getActiveShell();
if (activeShell != null
&& getCellEditor().getControl().getShell().equals(
activeShell.getParent())) {
Control[] children = activeShell.getChildren();
if (children.length == 1 && children[0] instanceof Table) {
/*
* CONTENT ASSIST: focus is lost to the content assist pop up -
* stay in focus
*/
getCellEditor().getControl().setVisible(true);
((MyTextCellEditor) getCellEditor()).setDeactivationLock(true);
return;
}
}
下面是MyTextCellEditor里面对于deactive lock的应用,MyTextCellEditor的deactive之前会判断一下deactive lock是否为true:
public boolean isDeactivationLocked() {
return deactivationLock;
}
public void deactivate() {
if (! isDeactivationLocked())
super.deactivate();
setDeactivationLock(false);
}
public void setDeactivationLock(boolean deactivationLock) {
this.deactivationLock = deactivationLock;
}
使用java自带的xml api生成的xml文件,其格式都是没有缩进的,每个element都是顶到最前面,今天终于找到了比较好的处理方法,赶紧记下来.
使用Java标准的JAXP来输出可以使用：
Transformer transformer = TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.transform(new DOMSource(document), new StreamResult(outputFile));
中间的红色代码是用于设置缩进的，比较遗憾的是JAXP只抽象出是否设置缩进（indent: yes|no），但并没有抽象出设置缩进量长度的常量（indent-number），所以默认的缩进量长度为0。如果有下面这样一个xml文档：<root><a><b>c</b></a></root>会被格式化为：
<root>
<a>
<b>c</b>
</a>
</root>
由于JAXP只是一个Java一个处理XML的框架，根据实现的不一样，可以传入实现特定的某个Key来设置缩进量。比如在Java 1.4下面，可以通过下面语句将缩进量设为2：
ransformer.setOutputProperty(
"{http://xml.apache.org/xslt}indent-amount", "2");
或
transformer.setOutputProperty(
"{http://xml.apache.org/xalan}indent-amount", "2");
上面两句不同之处仅在于命名空间。
而在Java 1.5下面，情况就有些复杂了。Java 1.5集成了JXAP 1.3（Java 1.4集成的是JXAP 1.1，不同之处参见http://java.sun.com/j2se/1.5.0/docs/guide/xml/jaxp/JAXP-Compatibility_150.html），实现基于Xerces类库。由于内部实现上的Bug，导致了设置缩进的不同：
TransformerFactory tf = TransformerFactory.newInstance();
tf.setAttribute("indent-number", new Integer(2));
Transformer transformer = tf.newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.transform(new DOMSource(document), new StreamResult(new?BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputFile)))));
注意红色代码的不同之处。第一句设置TransformerFactory的indent-number属性，在Java 1.4下面运行会抛出异常，因为其不支持该属性，而在Java 1.5中却只能通过该属性来设置缩进。后面标为红色的代码则是由于Sun实现上的Bug，只有通过StreamResult(Writer)构造函数生成才能正确设置缩进（通过OutputStream或者File生成的StreamResult是无法设置缩进的，其实现上会忽略任何非正式的属性，而仅仅采用rt.jar下面com\sun\org\apache\xml\internal\serializer\output_xml.properties中的配置。详细可以在com.sun.org.apache.xml.internal.serializer.ToStream类的setOutputStream方法中加断点进行分析）
?
如果忽略掉可移植性，确认绑定在Sun的JRE实现上面，则可以通过如下代码来更好的实现：
OutputFormat format = new OutputFormat(document);
format.setIndenting(true);
format.setIndent(2);
Writer output = new BufferedWriter( new FileWriter(outputFile) );
XMLSerializer serializer = new XMLSerializer(output, format);
serializer.serialize(document);
但是OutputFormat类和XMLSerializer类都是位于com.sun.org.apache.xml.internal.serialize包下。
如果应用对增加一个300K左右的jar包不敏感的话，我还是强烈推荐用dom4j来处理xml，其API设计的非常易用，写出来的代码比用JXAP写出来的代码漂亮多了，也容易维护，也不会出现上面那种两个Java版本不兼容的问题。
Java 对文件进行读写操作的例子很多，让初学者感到十分困惑，我觉得有必要将各种方法进行
一次分析，归类，理清不同方法之间的异同点。
一．在 JDK 1.0 中，通常是用 InputStream & OutputStream 这两个基类来进行读写操作的。
InputStream 中的 FileInputStream 类似一个文件句柄，通过它来对文件进行操作，类似的，在
OutputStream 中我们有 FileOutputStream 这个对象。
用FileInputStream 来读取数据的常用方法是：
FileInputStream fstream = new FileInputStream(args[0]);
DataInputStream in = new DataInputStream(fstream);
用 in.readLine() 来得到数据，然后用 in.close() 关闭输入流。
完整代码见 Example 1。
用FileOutputStream 来写入数据的常用方法是：
FileOutputStream out out = new FileOutputStream("myfile.txt");
PrintStream p = new PrintStream( out );
用 p.println() 来写入数据，然后用 p.close() 关闭输入。
完整代码见 Example 2。
二．在 JDK 1.1中，支持两个新的对象 Reader & Writer, 它们只能用来对文本文件进行操作，而
JDK1.1中的 InputStream & OutputStream 可以对文本文件或二进制文件进行操作。
用FileReader 来读取文件的常用方法是：
FileReader fr = new FileReader("mydata.txt");
BufferedReader br = new BufferedReader(fr);
用 br.readLing() 来读出数据，然后用br.close() 关闭缓存，用fr.close() 关闭文件。
完整代码见 Example 3。
用 FileWriter 来写入文件的常用方法是：
FileWriter fw = new FileWriter("mydata.txt");
PrintWriter out = new PrintWriter(fw);
在用out.print 或 out.println 来往文件中写入数据，out.print 和 out.println的唯一区别是后者写
入数据或会自动开一新行。写完后要记得 用out.close() 关闭输出，用fw.close() 关闭文件。
完整代码见 Example 4。
-------------------------------------------------------------- following is the source code of examples------------------------------------------------------
Example 1:
// FileInputDemo
// Demonstrates FileInputStream and DataInputStream
import java.io.*;
class FileInputDemo {
public static void main(String args[]) {
// args.length is equivalent to argc in C
if (args.length == 1) {
try {
// Open the file that is the first command line parameter
FileInputStream fstream = new FileInputStream(args[0]);
// Convert our input stream to a DataInputStream
DataInputStream in = new DataInputStream(fstream);
// Continue to read lines while there are still some left to read
while (in.available() !=0) {
// Print file line to screen
System.out.println (in.readLine());
}
in.close();
} catch (Exception e) {
System.err.println("File input error");
}
}
else
System.out.println("Invalid parameters");
}
}
Example 2:
// FileOutputDemo
// Demonstration of FileOutputStream and PrintStream classes
import java.io.*;
class FileOutputDemo
{
public static void main(String args[]) {
FileOutputStream out; // declare a file output object
PrintStream p; // declare a print stream object
try {
// connected to "myfile.txt"
out = new FileOutputStream("myfile.txt");
// Connect print stream to the output stream
p = new PrintStream( out );
p.println ("This is written to a file");
p.close();
} catch (Exception e) {
System.err.println ("Error writing to file");
}
}
}
Example 3:
// FileReadTest.java
// User FileReader in JDK1.1 to read a file
import java.io.*;
class FileReadTest {
public static void main (String[] args) {
FileReadTest t = new FileReadTest();
t.readMyFile();
}
void readMyFile() {
String record = null;
int recCount = 0;
try {
FileReader fr = new FileReader("mydata.txt");
BufferedReader br = new BufferedReader(fr);
record = new String();
while ((record = br.readLine()) != null) {
recCount++;
System.out.println(recCount + ": " + record);
}
br.close();
fr.close();
} catch (IOException e) {
System.out.println("Uh oh, got an IOException error!");
e.printStackTrace();
}
}
}
Example 4:
// FileWriteTest.java
// User FileWriter in JDK1.1 to writer a file
import java.io.*;
class FileWriteTest {
public static void main (String[] args) {
FileWriteTest t = new FileWriteTest();
t.WriteMyFile();
}
void WriteMyFile() {
try {
FileWriter fw = new FileWriter("mydata.txt");
PrintWriter out = new PrintWriter(fw);
out.print(“hi,this will be wirte into the file!”);
out.close();
fw.close();
} catch (IOException e) {
System.out.println("Uh oh, got an IOException error!");
e.printStackTrace();
}
}
}