对于想了解Web2.0编程思想：16条法则的读者，本文将提供新的信息，我们将详细介绍web编程原理，并且为您提供关于Java编程思想：File类list()方法、Java编程思想：File类其他方法、
对于想了解Web2.0编程思想：16条法则的读者，本文将提供新的信息，我们将详细介绍web编程原理，并且为您提供关于Java 编程思想：File 类 list () 方法、Java 编程思想：File 类其他方法、Java 编程思想：NIO 知识点、Java 编程思想：Preferences的有价值信息。
本文目录一览：- Web2.0编程思想：16条法则（web编程原理）
- Java 编程思想：File 类 list () 方法
- Java 编程思想：File 类其他方法
- Java 编程思想：NIO 知识点
- Java 编程思想：Preferences
Web2.0编程思想：16条法则（web编程原理）
1、在你开始之前，先定一个简单的目标。无论你是一个Web 2.0应用的创建者还是用户，请清晰的构思你的目标。就像“我需要保存一个书签”或者“我准备帮助人们创建可编辑的、共享的页面”这样的目标，让你保持最基础的需求。很多Web 2.0应用的最初吸引之处就是它的简单，避免并隐藏了那些多余的复杂性。站在创建者的立场，可以想象Google的几乎没有内容的主页，还有del.icio.us的简单的线条。从最终用户的角度来看，与之齐名的就是Diggdot.us所提供的初始化页面。你能够并且希望加入更多功能，但是先做好最开始的。在一个时候只做一个特性，完成一个目标。这听起来很太过于单纯化了，但它将使你更加专注，而且你也会明白我的意思。2、链接是最基础的思想。这就是我们称之为Web的一个理由。链接是把Web中各种实体连接起来的最基本的元素。你的信息、你的关系、你的导航，甚至是能够被写成URL的任何内容。这里有一个链接应该遵循的规则（其实你也不必严格的遵守）：
1. Web上的任何东西都是可以被URI或者是URL所连接的。
2. 把所有的链接都保存为他的原始出处，这样可以让你与任何人、在任何地方、任何时候都能分享它。
3. 第二条中任何时候的前提是链接必须是持久的，它不会在没有任何缘由的情况下被改变或者是消失。
4. 链接应该是人类可读的、稳定的、并且能够自我诠释的。
3、数据应该属于创建它的人。是的，你听我的。任何用户创建的、贡献的或分享的都是他们自己的，除非他们很明显的放弃这个权力来让你自由处置。他们贡献到Web上的任何信息都应该是可编辑的、能被删除的、并且能够取消共享，无论在任何时候，只要用户愿意。这也包含了那些间接的数据，像他们所关心的记录、日志、浏览历史、网站访问信息，或者是任何可以被跟踪的信息。所有的网站必须清晰简单的陈诉那些信息是用户创建的，并且提供他们停止创建的方法，甚至是清除的方法。
4、数据优先，体验与功能其次。无鬯俏谋尽⑼计⒁羝祷故鞘悠担琖eb最终还是把这些解析为数据。换句话说，你无法脱离数据去呈现内容。所有这些数据都通过那些易于发现的URL来定位（参见第2条）。通过另一种形式来看待这些，Web最终是名词优先，动词其次，虽然最近正在向动词偏移。来看看名词的例子：日历的条目、家庭照片、股票价格。还有一些动词的例子：定一个约会、共享一张图片、买一份股票。
5、做好积极分享一切的准备。尽可能的分享一切，你所拥有的所有数据，你所提供的所有服务。鼓励不遵循原有意图的使用，提倡贡献，不要那些需要分享的内容坚持设置为私有的。在分享与发现之后，提供易于使用的浏览方式是显而易见的需求。为什么呢：话说回来，你会从别人的共享之中受益匪浅。注意：这里没有许可让你去侵犯版权保护的法律，你不能够去分享你刻录的DVD或者是拥有商业版权音乐，因为你已经同意不会去分享这些东西。但是你可以发现并分享那些完全开放的媒体内容。一个小小的建议，你可以学习一下Creative Commons license（共创协议）.
6、Web是一个平台；要让它成长。当然，我们还有很多其他的平台（Windows、Linux、Mac），但是那些已经不是重点了。换句话说，Web是无法脱离的平台，不会中断的平台，你可以通过各种方式去扩展的平台。你在Web上提供的数据与服务将会成为Web一部分，最终你会在Web平台的某一处扮演你的角色。扮演好你的角色并照顾好后来者。
7、理解与信奉“阶梯性”。现在的Web越来越大，几乎蔓延到了全世界的所有国家，并且已经拥有了10亿用户。我的观点是Web的各个组成部分存在着细微的区别和不同，就像不同地方的用户那样。例如Web的设计部分：易用性永远优先于速度、可靠性、重用性与可集成性。你也应该提供同样的体验给你的用户。它已经被一次又一次的被人们在文档中强调，忠诚的用户很快会成为专业的用户，他们期待更快的速度还有更多。退一步支持他们。同样，也有很多很多的用户会进入这个阶梯的底端，如你所期待的那样。他们可能不会说你的语言，不熟悉你的文化，甚至不知道是如何到这里的。所以你需要向他们表达清楚。
8、任何东西都是可编辑的。或者是它应该被编织的更好。要确定的是，只有很少的东西是不能被编辑的，剩下的都可以，这是一个可写的Web。这并不意味着原始内容的丢失，而通常被理解为用户能够很容易的对内容加以评论，或者评注内容是在那里发现的。如果你对此应用的好，他们能够比你所想象的做的更多（把内容串起来并且给予原始内容来创建自己的，等等）。
9、Web上的身份是神圣的。不幸的是，这并不意味着你能够得到更多的隐私（这完全是上个世纪的想法）。但对身份的验证是必要的，你应该感谢那些只需一个邮件地址就能确定你身份的服务。这意味只要你对你的用户承诺了，你就必须保证他们的隐私安全。必要的时候，在这个世界的某处你还得为你的用户挺身而出，向当地的权威挑战。如果你没有打算那样做，你就得把实际情况告诉你的用户。另一方面，如果身份是必须的，不要试图伪装它，不然在某一天我们将会在Web上放弃我们的最后一点点隐私的权利。
10、了解流行的标准并且使用他们。从一个消费者或者是创作者的立场来看，数据将会以不同的格式与任何一个人交换。同时这样的数据也会反过来促进标准的完善与采纳。这通常意味像RSS、 OPML、XHTML、Simple XML、JSON等简单标准的流行，而避免SOAP、XSD，还有RDF、ATOM也一样，使用它们会给我的内心带来痛苦。请你也为你所钟爱的标准投上一票来支持它们。
11、遵循无意使用的规律。如果你把非常有趣的数据和服务用广泛使用的格式开放和共享出去，你将会得到你所应得的，其他人也将会基于你的那一块Web平台来构建。或许还会从别人那里得到更多，所以为这个做一下准备比较好。我已记不清有多少次我看到一个播客（podcasting）服务因为流行过渡而导致服务垮掉，就是因为他们被 Slashdot和del.icio.us给收录了。这一点要知道：网络上的大量化意味着如果一个内容非常有趣，即使是一个很小的角落也会得到惊人的访问量。鼓励使用这种方式，它还是非常有价值的，前提是你要有所准备。
12、粒化你的数据与服务。我们应该在很早以前就明白这些，大规模集成的数据仅仅适用于无需管理的下载与批量操作。分解你的数据，让他们独立成可描述的URL地址，对你的服务也一样。反过来说，你不要创建一些巨大的、复杂的、像圣诞树那样的数据结构和服务。保持简单，要非常的简单。让这些分离的片断能够容易的被重组和发现。
13、提供用户能够单独受益的数据和服务。渐渐依赖于这种社会化参与是存在风险的，你需要让你的用户有一点点动机来贡献时间、热情和信息，除非他们能够直接受益。社会化分享比个体行为的利益大很多，除非你能够激发用户的个人动机，否这你将无法享受这份厚礼。
14、让用户组织并过滤信息。不一定是必须的，但却是非常重要的。让用户以他们自己的方式来标注和组织数据，因为你自己是永远无法及时的处理他们的。用户会按照他们自己理解的最佳方式来处理并构建。要保证你的Web服务能够按照用户所需所想的方式来工作。这也是标签（tagging）和通俗分类（folksonomies ）的方式如此成功的主要因素。
15、提供丰富的用户体验。Web一直都在和本地的应用程序进行着激烈的竞争。为什么？因为本地程序还是感觉上好一些，速度也快一些。但是这不会长久的（确信在5年或者15年后，这种竞争就不存在了）。是的，我在谈论Rich Internet Applications, Ajax, 还有那些不可思议的交互应用。他们让Web成为了一个真正的“无平台”的平台，如果你知道我是怎么想的。
16、信奉并支持快速改进和反馈。这个通常意味着加快步伐，但也意味着使用轻量级的工具、技术和不要做出那些适得其反的痛苦决定（例如使用一个被层层环绕的Ajax框架来代替可以通过混合来实现的，或者用C++来构建所有的东西，其实使用Ruby会更好一些）。这同时也意味着需要一个非常快速的方式来处理错误报告，修复Bug，释放新版本。从一个用户的角度来看，报告你所发现的任何问题，还有那些你经常抱怨的地方，甚至那些都不是一个Bug。
当然，Web 2.0是一个极其广泛和深奥的话题，没有一个人能够列举出它的所有重点和特征。如果你对此充满了兴趣，请花一点时间来补充我没有提到的地方。我想这就是Web 2.0的参与性吧！
原作者的这个标题借鉴了Bruce Eckel的两本畅销书的名字：《Thinking in C++》和《Thinking in Java》，《C++编程思想》与《Java编程思想》，在此说明一下为什么要这样翻译这个题目:)
Java 编程思想：File 类 list () 方法
import java.util.regex.Pattern;
import java.io.File;
import java.io.FilenameFilter;
public class Test {
public static void main(String[] args) {
DirList.test();
DirList2.test();
DirList3.test();
}
}
//方案一：实现一个FilenameFilter接口的类
class DirFilter implements FilenameFilter {
private Pattern pattern;
public DirFilter(String regex) {
pattern=Pattern.compile(regex);
}
@Override
public boolean accept(File dir, String name) {
return pattern.matcher(name).matches();
}
}
class DirList {
public static void test() {
File path = new File("./src");
String[] list=path.list(new DirFilter("java$"));
System.out.println("DirList:"+list.length);
}
}
//方案二：使用匿名内部类
class DirList2 {
private static FilenameFilter filter(String regex) {
return new FilenameFilter() {
Pattern pattern = Pattern.compile(regex);
@Override
public boolean accept(File dir, String name) {
return pattern.matcher(name).matches();
}
};
}
public static void test() {
File file = new File("./src");
String[] list = file.list(filter("java$"));
System.out.println("DirList2:"+list.length);
}
}
//方案三：使用匿名内部类
class DirList3 {
public static void test() {
File path = new File(".//src");
String[] list = path.list(new FilenameFilter() {
private Pattern pattern = Pattern.compile("java$");
@Override
public boolean accept(File dir, String name) {
return pattern.matcher(name).matches();
}
});
System.out.println("DirList3:"+list.length);
}
}
Java 编程思想：File 类其他方法
import java.io.File;
public class Test {
public static void main(String[] args) {
MakeDirectories.test();
}
}
class MakeDirectories {
//用于展示File对象各种信息
private static void fileData(File file) {
StringBuilder sb = new StringBuilder();
sb.append("\nAbsolute path:"+ file.getAbsolutePath());
sb.append("\n Can Read:"+ file.canRead());
sb.append("\n Can Write:"+ file.canWrite());
sb.append("\n Get Name:"+ file.getName());
sb.append("\n Get Parent:"+ file.getParent());
sb.append("\n Get Path:"+ file.getPath());
sb.append("\n Length:"+ file.length());
sb.append("\n LastModified:"+ file.lastModified());
sb.append("\n Is File:"+ file.isFile());
sb.append("\n Is Directory:"+ file.isDirectory());
System.out.println(sb.toString());
}
//用于测试rename方法
private static void rename(String file1,String file2) {
File o = new File(file1);
File n = new File(file2);
o.renameTo(n);
}
//
private static void deleteandmkdirs(String file) {
File f = new File(file);
//文件存在，则删除
if (f.exists()) {
f.delete();
}
//文件不存在，则创建
else {
f.mkdirs();
}
}
public static void test() {
//File f = new File(".");
//fileData(f);
// String file1="./file1";
// String file2="./file2";
// //File f1 = new File(file1);
// //File f2 = new File(file2);
// rename(file1,file2);
// File f1 = new File(file1);
// File f2 = new File(file2);
// fileData(f1);
// fileData(f2);
}
}
Java 编程思想：NIO 知识点
import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.util.*;
public class Test {
public static void main(String[] args) {
// GetChannel.test();
// BufferToText.test();
// AvailableCharSets.test();
// GetData.test();
// IntBufferDemo.test();
// ViewBuffers.test();
// Endians.test();
// UsingBuffers.test();
LargeMapperFiles.test();
}
}
/*
将字节存放在ByteBuffer的方法：
1.通过put方法直接对它们进行填充，填入一个或多个字节，或基本数据类型
2.通过warp方法将已存在的字节数组包装到ByteBuffer中，一旦如此，就不需要复制
底层的数组，而是把它作为所产生的ByteBuffer的存储器，称之为数组支持的ByteBuff。
*/
/*
1.对于只读操作，需要显示静态的allocate方法来分配ByteBuffer
2.对于read方法，调用read告知FileChannel向ByteBuffer存储字节后，需要调用缓冲器上
的flip，让它做好让别人读取字节的准备。
3.对于read方法，如果我们打算用缓冲器执行进一步的read操作，则我们必须调用clear方法
来为每一个read做好准备
*/
class GetChannel {
private static final int BSIZE = 1024;
public static void test() {
try {
//FileOutputStream测试
FileChannel fc1 = new FileOutputStream("./src/data").getChannel();
fc1.write(ByteBuffer.wrap("Some test".getBytes()));
fc1.close();
//FileInputStream测试
FileChannel fc2 = new FileInputStream("./src/data").getChannel();
ByteBuffer buff = ByteBuffer.allocate(BSIZE);
fc2.read(buff);
buff.flip();
/*
这个地方和下一个案例的需求是不同的：
这个案例中我需要将buff中的数据一个一个字符的打印出出来，get方法
就像迭代器中的next方法，每次调用时都会向后移动一个位置：
while (buff.hasRemaining())
System.out.println((char)buff.get());
下一个案例中，是从文件中读取，当文件所有内容都被读取后，调用read
放法，就会在buffer中存入一个-1的值：
while (fc1.read(buffer) != -1) {
buffer.flip();
fc2.write(buffer);
buffer.clear();
}
}
*/
while (buff.hasRemaining()) {
System.out.println((char)buff.get());
}
//RandomAccessFile测试
FileChannel fc3 = new RandomAccessFile("./src/data","rw").getChannel();
fc3.position(fc3.size());
fc3.write(ByteBuffer.wrap("Some more".getBytes()));
fc3.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ChannelCopy {
private static final int BSIZE = 1024;
public static void test() {
try{
FileChannel fc1 = new FileInputStream("./src/data").getChannel();
FileChannel fc2 = new FileOutputStream("./src/data").getChannel();
ByteBuffer buffer = ByteBuffer.allocate(BSIZE);
/*
FileChannel和ByteBuffer的使用逻辑：
1.得到FileChannel，也就是书中说的煤矿
2.建立ByteBuffer，也就是书中说的卡车
3.通知煤矿向卡车转载货物
4.使用卡车中的货物
5.清空卡车中的货物
*/
while (fc1.read(buffer) != -1) {
buffer.flip();
fc2.write(buffer);
buffer.clear();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*
上一个案例并不是理想的使用方式，transferTo和transferFrom则允许我们将一个通道与
另一个通道直接相连
*/
class TransferTo{
public static void test() {
try{
FileChannel in = new FileInputStream("./src/data").getChannel();
FileChannel out = new FileOutputStream("./src/data").getChannel();
//将in中的位置为0，长度为in.size()的数据移动到out这个通道中
in.transferTo(0,in.size(),out);
//将in中的位置为0，长度为in.size()的数据移动到out这个通道中
out.transferFrom(in,0,in.size());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class BufferToText {
private static final int BSIZE = 1024;
public static void test() {
try {
//第一步，打开一个文件向里面写点东西
FileChannel fc1 = new FileOutputStream("./src/data1").getChannel();
fc1.write(ByteBuffer.wrap("some text".getBytes()));
fc1.close();
//第二步，读取这个文件，尝试使用buffer的asCharBuffer进行输出
FileChannel fc2 = new FileInputStream("./src/data1").getChannel();
ByteBuffer buffer = ByteBuffer.allocate(BSIZE);
fc2.read(buffer);
buffer.flip();
System.out.println("buffer.asCharBuffer(): "+buffer.asCharBuffer());
//第三步，使用系统默认的方式解码
buffer.rewind(); //移动光标到开始部分
String encoding = System.getProperty("file.encoding");
System.out.println("encoding: "+encoding);
System.out.println("Decode use "+encoding+" :"+Charset.forName(encoding).decode(buffer));
//第四步，写入东西时指定编码方式
FileChannel fc3 = new FileOutputStream("./src/data2").getChannel();
fc3.write(ByteBuffer.wrap("some text".getBytes("UTF-16BE")));
fc3.close();
//第五步，将写入的东西读出来
FileChannel fc4 = new FileInputStream("./src/data2").getChannel();
ByteBuffer buffer4 = ByteBuffer.allocate(BSIZE);
fc4.read(buffer4);
buffer4.flip();
System.out.println("buffer4.asCharBuffer(): "+buffer4.asCharBuffer());
//第六步，使用CharBuffer进行写
FileChannel fc5 = new FileOutputStream("./src/data2").getChannel();
ByteBuffer buffer5 = ByteBuffer.allocate(24);
buffer5.asCharBuffer().put("some Text");
fc5.write(buffer5);
fc5.close();
//第七步，将写入的内容读出来
FileChannel fc6 = new FileInputStream("./src/data2").getChannel();
ByteBuffer buffer6 = ByteBuffer.allocate(BSIZE);
fc6.read(buffer6);
buffer6.flip();
System.out.println("buffer6.asCharBuffer(): "+buffer6.asCharBuffer());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class AvailableCharSets {
public static void test() {
SortedMap<String,Charset> charset = Charset.availableCharsets();
Iterator<String> iter_name = charset.keySet().iterator();
while (iter_name.hasNext()) {
String charsetName = iter_name.next();
System.out.print(charsetName);
Set<String> aliases= charset.get(charsetName).aliases();
Iterator<String> iter_alia = aliases.iterator();
if(iter_alia.hasNext())
System.out.print(":");
while (iter_alia.hasNext()) {
System.out.print(iter_alia.next()+" ");
}
System.out.println("");
}
}
}
class GetData{
private static final int BSIZE = 1024;
public static void test() {
ByteBuffer b = ByteBuffer.allocate(BSIZE);
//b在创建是会自动分配0
int i = 0;
while (i++ < b.limit()) {
if (b.get() != 0) {
System.out.println("not zero.");
}
}
System.out.println("i = "+i);
//存储并读取一个char
b.rewind();
b.asCharBuffer().put("Hello");
char c;
while ((c = b.getChar()) != 0) {
System.out.print(c);
}
System.out.println();
//存储并读取一个short
b.rewind();
b.asShortBuffer().put((short) 471142);
System.out.println("b.getShort(): "+b.getShort());
//存储并读取一个int
b.rewind();
b.asIntBuffer().put(992341);
System.out.println("b.getInt(): "+b.getInt());
//存储并读取一个long
b.rewind();
b.asLongBuffer().put(234141532234L);
System.out.println("b.getLong(): "+b.getLong());
//存储并读取一个float
b.rewind();
b.asFloatBuffer().put(23414.134f);
System.out.println("b.getFloat(): "+b.getFloat());
//存储并读取一个double
b.rewind();
b.asDoubleBuffer().put(234.1432234);
System.out.println("b.getDouble(): "+b.getDouble());
}
}
class IntBufferDemo{
private static final int BSIZE = 1024;
public static void test() {
ByteBuffer b = ByteBuffer.allocate(BSIZE);
IntBuffer ib = b.asIntBuffer();
ib.put(new int[]{1,2,3,4,5});
System.out.println(ib.get(3));
System.out.println(ib.get(4));
ib.put(3, 100);
System.out.println(ib.get(3));
System.out.println(ib.get(4));
System.out.println("Setting a new limit before rewinding the buffer");
ib.flip();
while (ib.hasRemaining()) {
int i = ib.get();
System.out.println(i);
}
}
}
class ViewBuffers {
public static void test() {
ByteBuffer b = ByteBuffer.wrap(new byte[]{0,0,0,0,0,0,0,''a''});
b.rewind();
System.out.println("ByteBuffer:");
while (b.hasRemaining()) {
System.out.println(b.position()+"-->"+b.get()+".");
}
b.rewind();
CharBuffer cb = b.asCharBuffer();
System.out.println("CharBuffer:");
while (cb.hasRemaining()) {
System.out.println(cb.position()+"-->"+cb.get()+".");
}
}
}
class Endians {
public static void test() {
ByteBuffer b = ByteBuffer.wrap(new byte[12]);
b.asCharBuffer().put("abcdef");
System.out.println(Arrays.toString(b.array()));
b.rewind();
b.order(ByteOrder.BIG_ENDIAN);
b.asCharBuffer().put("abcdef");
System.out.println(Arrays.toString(b.array()));
b.rewind();
b.order(ByteOrder.LITTLE_ENDIAN);
b.asCharBuffer().put("abcdef");
System.out.println(Arrays.toString(b.array()));
}
}
class UsingBuffers {
private static void symmetricScramble(CharBuffer buffer) {
while (buffer.hasRemaining()) {
buffer.mark();
char c1 = buffer.get();
char c2 = buffer.get();
buffer.reset();
buffer.put(c2).put(c1);
}
}
public static void test() {
char[] data = "UsingBuffers".toCharArray();
ByteBuffer bb = ByteBuffer.allocate(data.length * 2);
CharBuffer cb = bb.asCharBuffer();
cb.put(data);
System.out.println(cb.rewind());
symmetricScramble(cb);
System.out.println(cb.rewind());
symmetricScramble(cb);
System.out.println(cb.rewind());
}
}
class LargeMapperFiles {
private static final int length = 0X8FFFFFF; //128 MB
public static void test() {
try {
MappedByteBuffer out = new RandomAccessFile("./src/data", "rw")
.getChannel()
.map(FileChannel.MapMode.READ_WRITE, 0,length);
for (int i = 0; i < length; i++) {
out.put((byte)''x'');
}
System.out.println("Finished writing...");
for (int i = length / 2; i < length / 2 + 6; i++) {
System.out.println((char)out.get(i));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Java 编程思想：Preferences
import java.util.prefs.BackingStoreException;
import java.util.prefs.Preferences;
public class Test {
public static void main(String[] args){
PreferencesDemo.test();
}
}
/*
这里用的是userNodeForPackage()，但是我们也可以选择用systemNodeForPackage；
虽然可以任意选择，但是最好使用“user”用于个别用户的偏好，用“system”用于通用的安
装配置。因为main是静态的，因此PreferencesDemo.class可以用来表示节点，但是非静
态的方法内部，我们通常使用getClass()，尽管我们不一定非要把当前的类作为节点标识符
，但这任不失为一种很有用的方法。
——不明所以
数据储存在哪了？在程序第一次运行之后，并没有垂涎任何本地文件。Preferences API利
用合适的系统资源完成这个任务，并且这些资源会随着操作系统的不同而不同。例如在
Windows系统里，就利用注册表（因为它已经有了“键值对”这样的节点对层次结构了）。但是
最重要的一点是，它已经神奇般地为我们储存了信息，所以我们不必担心不同的操作系统怎么
运作的
*/
class PreferencesDemo {
public static void test() {
Preferences prefs = Preferences.userNodeForPackage(Test.class);
prefs.put("Location", "Oz");
prefs.put("Location", "Ruby Slippers");
prefs.putInt("Companions", 4);
prefs.putBoolean("Are there witches?", true);
//典型的用法
int usageCount = prefs.getInt("UsageCount", 0);
usageCount++;
prefs.putInt("UsageCount", usageCount);
try {
for (String key : prefs.keys()) {
System.out.println(key + ":" + prefs.get(key, null));
}
System.out.println("How many companions does Dorothy have?");
System.out.println(prefs.getInt("Companions", 0));
} catch (BackingStoreException e) {
e.printStackTrace();
}
}
}
今天的关于Web2.0编程思想：16条法则和web编程原理的分享已经结束，谢谢您的关注，如果想了解更多关于Java 编程思想：File 类 list () 方法、Java 编程思想：File 类其他方法、Java 编程思想：NIO 知识点、Java 编程思想：Preferences的相关知识，请在本站进行查询。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
