Java容器类List、ArrayList、Vector及map、HashTable、HashMap分别的区别
Java容器类List、ArrayList、Vector及map、HashTable、HashMap分别的区别.
2007年05月21日星期一09:23
一、List与ArrayList的区别
List->AbstractList->ArrayList
(1) List是一个接口，ArrayList是一个实现了List接口的具体类。
他们是父子关系，我们常用的是ArrayList,但常用List的引用去操作ArrayList
这是一个简单的面向接口编程的一种，如：List myList = new ArrayList();
(2)他们主要是用来保存对象的集合，记得是保存对象的哦，你可别传个int(类)进去啊
(3)要取出它里面保存的对象可以用下标，如：Object aaa = myList.get(0);
这样我们就把保存在myList里的第一个对象取出来给了aaa 啦。
二、祥解
---------------------------1楼------------------------------------
好像List和Map都是接口
不能实例化的
以前这么写List list = new Vector();
现在这么写List list = new ArrayList();
用ArrayList 代替了Vector 因为前者的性能比后者好；
但是两个都是实现了List借口的
同理Map map = new HashTable();(以前)
Map map = new HashMap();(现在)
-------------------------------2楼-------------------------------
ArrayList和HashMap是异步的，Vector和HashTable是同步的，所以Vector和HashTable是线程安全的，而ArrayList和HashMap并不是线程安全的。因为同步需要花费机器时间，所以Vector和HashTable的执行效率要低于ArrayList和HashMap。Collection
├List
│├LinkedList
│├ArrayList
│└V ector
│└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
List接口
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java 的数组。
和下面要提到的Set不同，List允许有相同的元素。
除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。
ArrayList类
ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
Map接口
请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。
HashMap类
HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
----------------------------------3楼------------------------------------------
1.
List是接口，List特性就是有序,会确保以一定的顺序保存元素.
ArrayList是它的实现类,是一个用数组实现的List.
Map是接口,Map特性就是根据一个对象查找对象.
HashMap是它的实现类,HashMap用hash表实现的Map,就是利用对象的hashcode(hashcode()是Object的方法)进行快速散列查找.(关于散列查找,可以参看<<数据结构>>)
2.
一般情况下,如果没有必要,推荐代码只同List,Map接口打交道.
比如:List list = new ArrayList();
这样做的原因是list就相当于是一个泛型的实现,如果想改变list的类型,只需要:
List list = new LinkedList();//LinkedList也是List的实现类,也是ArrayList的兄弟类
这样,就不需要修改其它代码,这就是接口编程的优雅之处.
另外的例子就是,在类的方法中,如下声明:
private void doMyAction(List list){}
这样这个方法能处理所有实现了List接口的类,一定程度上实现了泛型函数.
3.
如果开发的时候觉得ArrayList,HashMap的性能不能满足你的需要,可以通过实现List,Map(或者Collection)来定制你的自定义类
java创建txt文件并进行读写修改操作
java创建txt文件并进行读写修改操作 import java.io.*;/** * * 功能描述：创建TXT文件并进行读、写、修改操作* */ public class ReadWriteFile { public static BufferedReader bufread; //指定文件路径和名称 private static String path = "D:/suncity.txt"; private static File filename = new File(path); private static String readStr =""; /** * 创建文本文件. * @throws IOException * */ public static void creatTxtFile() throws IOException{ if (!filename.exists()) { filename.createNewFile(); System.err.println(filename + "已创建！"); }
} /** * 读取文本文件. * */ public static String readTxtFile(){ String read; FileReader fileread; try { fileread = new FileReader(filename); bufread = new BufferedReader(fileread); try { while ((read = bufread.readLine()) != null) { readStr = readStr + read+ "\r\n"; } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block
Java 输入输出流及文件读写详解
I/O类体系 在JDK API中，基础的IO类都位于java.io包，而新实现的IO类则位于一系列以java.nio开头的包名中，这里首先介绍java.io包中类的体系结构。 按照前面的说明，流是有方向的，则整个流的结构按照流的方向可以划分为两类： 1、输入流： 该类流将外部数据源的数据转换为流，程序通过读取该类流中的数据，完成对于外部数据源中数据的读入。 2、输出流： 该类流完成将流中的数据转换到对应的数据源中，程序通过向该类流中写入数据，完成将数据写入到对应的外部数据源中。 而在实际实现时，由于JDK API历史的原因，在java.io包中又实现了两类流：字节流(byte stream)和字符流(char stream)。这两种流实现的是流中数据序列的单位，在字节流中，数据序列以byte为单位，也就是流中的数据按照一个byte一个byte的顺序实现成流，对于该类流操作的基本单位是一个byte，而对于字节流，数据序列以char为单位，也就是流中的数据按照一个char一个插入的顺序实现成流，对于该类流操作的基本单位是一个char。 另外字节流是从JDK1.0开始加入到API中的，而字符流则是从JDK1.1开始才加入到API中的，对于现在使用的JDK版本来说，这两类流都包含在API的内部。在实际使用时，字符流的效率要比字节流高一些。 在实际使用时，字符流中的类基本上和字节流中的类对应，所以在开始学习IO类时，可以从最基础的字节流开始学习。 在SUN设计JDK的IO类时，按照以上的分类，为每个系列的类设计了一个父类，而实现具体操作的类都作为该系列类的子类，则IO类设计时的四个体系中每个体系中对应的父类分别是： 字节输入流InputStream 该类是IO编程中所有字节输入流的父类，熟悉该类的使用将对使用字节输入流产生很大的帮助，下面做一下详细的介绍。 按照前面介绍的流的概念，字节输入流完成的是按照字节形式构造读取数据的输入流的结构，每个该类的对象就是一个实际的输入流，在构造时由API完成将外部数据源转换为流对象的操作，这种转换对程序员来说是透明的。在程序使用时，程序员只需要读取该流对象，就可以完成对于外部数据的读取了。
java读写文件避免中文乱码
1、JAVA读取文件，避免中文乱码。 /** * 读取文件内容 * * @param filePathAndName * String 如c:\\1.txt 绝对路径 * @return boolean */ public static String readFile(String filePathAndName) { String fileContent = ""; try { File f = new File(filePathAndName); if(f.isFile()&&f.exists()){ InputStreamReader read = new InputStreamReader(new FileInputStream(f),"UTF-8"); BufferedReader reader=new BufferedReader(read); String line; while ((line = reader.readLine()) != null) { fileContent += line; } read.close(); } } catch (Exception e) { System.out.println("读取文件内容操作出错"); e.printStackTrace(); } return fileContent; } 2、JAVA写入文件，避免中文乱码。 public static void writeFile(String filePathAndName, String fileContent) { try { File f = new File(filePathAndName); if (!f.exists()) { f.createNewFile(); } OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(f),"UTF-8"); BufferedWriter writer=new BufferedWriter(write); //PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(filePathAndName))); //PrintWriter writer = new PrintWriter(new FileWriter(filePathAndName)); writer.write(fileContent);
java文件读写代码
1、按字节读取文件内容 2、按字符读取文件内容 3、按行读取文件内容 4、随机读取文件内容 public class ReadFromFile { /** * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。 */ 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); }
如何使用java语言向文件中输入数据和从文件中读取数据
1、文件输入流 向文件中写入数据 Sink输出流 节点流-——文件节点 FileOutStream——字节形式存储内容 FileWriter——字符型式存储内容 import java.io.*; public class P1{ public static void main(String[]args)throws Exception{ //TODO Auto-generated method stub FileOutputStream out=new FileOutputStream("text.txt"); out.write('a'); String str="Hello world"; byte[]buffer=str.getBytes(); out.write(buffer); out.write(buffer,6,5); out.close(); } } 输出：aHello world!world 2、从文件中读取数据 Source输入流 节点流——文件节点 FileReader——字符文件 FileInputStream——字节文件 import java.io.*; public class P1{ public static void main(String[]args)throws Exception{ //TODO Auto-generated method stub FileInputStream input=new FileInputStream("text.txt"); int ch=input.read();//读入一个字节 while(ch!=-1) { System.out.print((char)ch); ch=input.read(); } input.close();
java File文件操作和文件流的详解(福哥出品)
一. 创建文件 （1）最常用的（获得一个固定路径下的文件对象） File parentFile = new File(“D:\\My Documents\\.....”);//参数是一个路径的字符串。 （2）在父目录创建一个名为child的文件对象，child 为文件对象的名字 File chileFile= new File(“D:\\My Documents\\.....”,String child); 或File chileFile= new File(parentFile,String child); 二,常见文件夹属性和方法 （1）createNewFile（）； 该方法的作用是创建指定的文件。该方法只能用于创建文件，不能用于创建文 件夹，且文件路径中包含的文件夹必须存在 File file=new ("D:\\My Document\\text.txt"); file.createNewFile(); 这样就会在D盘下的My Document 创建text.txt的记事本（注意：首先得保 证D盘下有My Documen这个文件夹） （2）mkdir(); 根据File对象的名字(路径)创建一个目录(文件夹)，如果是相对目录，则新建的目
录在当前目录下 （3）mkdirs(); 如果File对象名字有多级目录，则可以调用该方法一次性创建多级目录。 （4）exists(); 判断File对象指向的文件是否存在，返回一个boolean类型（5）isDirectory（）； 判断File对象指向的文件是否为目录，返回一个boolean类型的值，true或者false。 （6）getName();获得文件名称（不带路径） （7）length（）； 得到File对象指向文件的长度，以字节计算，返回一个长整形的值(long);注意：在 系统中，文件夹(目录)的大小为零，也就是不占用空间，使用length()时返回的是0 （8）delete（）; 删除File对象所指定的文件 （9）isFile（）； 判断File对象指向的文件是不是标准文件（就像图片，音乐文件等） 三,文件的属性和方法 1.File.separator 当前操作系统的名称分隔符，等于字符串“\”.
Java流(文件读写操作)
Java流 一、流的分类 ?按数据流动方向 –输入流：只能从中读取字节数据，而不能向其写出数据 –输出流：只能向其写入字节数据，而不能从中读取数据?按照流所处理的数据类型 –字节流：用于处理字节数据。 –字符流：用于处理Unicode字符数据。 ?按照流所处理的源 –节点流:从/向一个特定的IO设备读/写数据的流。（低级流）–处理流:对已存在的流进行连接和封装的流。（高级流）二、缓冲流 ?缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。 ?J2SDK提供了四种缓存流： –BufferedReader –BufferedWriter –BufferedInputStream s –BufferedOutputStream
?缓冲输入流支持其父类的mark()和reset()方法： –mark()用于“标记”当前位置，就像加入了一个书签，可以使用reset()方法返回这个标记重新读取数据。?BufferedReader提供了readLine()方法用于读取一行字符串（以\r 或\n分隔）。 ?BufferedWriter提供了newLine()用于写入一个行分隔符。 ?对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()方法将会使内存中的数据立刻写出。 三、类层次 3.1、InputStream类层次
3.2、OutputStream类层次 3.3、Reader类层次
3.4、Writer类层次 四、常用的字符流与字节流的转化 说明： 1.字节流用于读写诸如图像数据之类的原始字节流。 2.字符流用于读写诸如文件数据之类的字符流。 3.低级流能和外设交流。 4.高级流能提高效率。 5.InputStreamReader 是字节流通向字符流的桥梁。 6.OutputStreamWriter 是字符流通向字节流的桥梁。
java将对象保存到文件中从文件中读取对象
1.保存对象到文件中 Java语言只能将实现了Serializable接口的类的对象保存到文件中，利用如下方法即可： public static void writeObjectToFile(Object obj) { File file =new File("test.dat"); FileOutputStream out; try { out = new FileOutputStream(file); ObjectOutputStream objOut=new ObjectOutputStream(out); objOut.writeObject(obj); objOut.flush(); objOut.close(); System.out.println("write object success!"); } catch (IOException e) { System.out.println("write object failed"); e.printStackTrace(); } } 参数obj一定要实现Serializable接口，否则会抛出 java.io.NotSerializableException异常。另外，如果写入的对象是一个容器，例如List、Map，也要保证容器中的每个元素也都是实现了Serializable 接口。例如，如果按照如下方法声明一个Hashmap，并调用writeObjectToFile方法就会抛出异常。但是如果是 Hashmap
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:
java文件读写常见问题
1.public FileOutputStream(String name)throws FileNotFoundException{ 2.this(name!=null?new File(name):null,false); 3.} 4. 5.public FileOutputStream(File file,boolean append) 6.throws FileNotFoundException 7.{//注意：file.getPath()就是fullPath 8.String name=(file!=null?file.getPath():null); 9.SecurityManager security=System.getSecurityManager(); 10.if(security!=null){ 11.security.checkWrite(name); 12.} 13.if(name==null){ 14.throw new NullPointerException(); 15.} 16.fd=new FileDescriptor(); 17.this.append=append; 18.if(append){ 19.openAppend(name); 20.}else{ 21.open(name); 22.} 23.} FileInputStream（作为输入源的文件） If the named file 1.does not exist（不存在）
2.is a directory rather than a regular file（存在，但，是个目录） 3.for some other reason cannot be opened for reading（无法打开） then a FileNotFoundException is thrown. FileOutputStream（接受写，被写） If the file 1.exists but is a directory rather than a regular file（是个目录） 2.does not exist but cannot be created（无此文件，且无法创建此文件。隔着一个不存在的目录则无法创建，否则可以创建） 3.cannot be opened for any other reason（无法打开） then a FileNotFoundException is thrown. 例如，存在下面的情况 C:/abc.txt（不存在abc.txt） C:/AFolder/abc.txt（不存在AFolder/abc.txt，隔着一个不存在的目录） C:/Folder（已存在文件夹Folder） FileInputStream C:/abc.txt（不存在abc.txt。这是输入源，隔不隔不存在的目录都一样，只要不存在就不行） java.io.FileNotFoundException:C:\abc.txt(系统找不到指定的文件。) C:/AFolder/abc.txt（不存在AFolder/abc.txt。这是输入源，隔不隔不存在的目录都一样，只要不存在就不行） java.io.FileNotFoundException:C:\AFolder\abc.txt(系统找不到指定的路径。) C:/Folder（已存在文件夹Folder） java.io.FileNotFoundException:C:\Folder(拒绝访问。) FileOutputStream C:/abc.txt（不存在abc.txt） 可以成功（因为Parent Folder已经存在了，abc.txt是否存在无所谓。不隔着不存在的目录，就可以创建成功）
Java文件读写操作代码实现
Java文件读写操作代码实现 package test; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; /** * 一、BufferedReader类 public class BufferedReader extends Reader * 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值足够大。 * 通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader包装所有其 read() * 操作可能开销很高的 Reader（如 FileReader和 InputStreamReader）。 * BufferedReader流能够读取文本行,通过向BufferedReader传递一个Reader对象
* ,来创建一个BufferedReader对象,之所以这样做是因为FileReader没有提供读取文本行的功能. * * 二、InputStreamReader类 * * InputStreamReader 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。 * * 构造方法： * * InputStreamReader isr = new InputStreamReader(InputStream * in);//构造一个默认编码集的InputStreamReader类 * * InputStreamReader isr = new InputStreamReader(InputStream in,String * charsetName);//构造一个指定编码集的InputStreamReader类。 * * 参数 in对象通过 InputStream in = System.in;获得。//读取键盘上的数据。 * * 或者 InputStream in = new FileInputStream(String fileName);//读取文件中的数据。可以看出 * FileInputStream 为InputStream的子类。 * * 主要方法：int read();//读取单个字符。 int read(char []cbuf);//将读取到的字符存到
Java指定编码读写文件(UTF-8)
Java指定编码读写文件（UTF-8） 读取 import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; String FileContent = ""; // 文件很长的话建议使用StringBuffer try { FileInputStream fis = new FileInputStream("d:\\input.txt"); InputStreamReader isr = new InputStreamReader(fis, "UTF-8"); BufferedReader br = new BufferedReader(isr); String line = null; while ((line = br.readLine()) != null) { FileContent += line; FileContent += "\r\n"; // 补上换行符 } } catch (Exception e) { e.printStackTrace(); } 写入 import java.io.FileOutputStream; import java.io.OutputStreamWriter; String FileContent = "文件内容"; try { FileOutputStream fos = new FileOutputStream("d:\\output.txt"); OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8"); osw.write(FileContent); osw.flush(); } catch (Exception e) { e.printStackTrace(); }
Java读取TXT文本文件乱码解决方案
Java读取TXT文本文件乱码解决方案 今天在解析一个文本文件的时候出现了乱码，以前从未遇到，花了点时间解决了，在此总结一下： 首先，先看一下解析的代码： private String[] getProjectData(File file){ String[] data = null; try { BufferedReader br = new BufferedReader(new FileReader(file)); String str = br.readLine(); data = str.split("\t"); br.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return data; } 这个方法很简单，就是获取txt文件中的一行数据，然后转换为数组，我这个文本中只有一行。就这种情况下获取到的str是乱码，我想出现乱码肯定是字符集编码的问题，然后自己新建了一个文本文档测试没有问题（开始用的文本时别的程序导出的），所以我估计是开始那个txt文件编码的问题，查看发现是Unicode编码（如何查看txt的编码呢，教你一个笨笨的办法：打开文件——另存为，然后看到最下面的编码，默认选择的就是当前文档的编码格式），问题就出现在这里。问题找到了就好解决了，修改代码为： private String[] getProjectData(File file){ String[] data = null; try { BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file),"UTF-16")); String str = br.readLine(); data = str.split("\t"); br.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return data; } 使用文件流读取，转换编码为“UTF-16”，这样乱码问题就解决了。 归纳一下： txt文本文档有四种编码选项：ANSI、Unicode、Unicode big endian、UTF-8;默认应该是ANSI 选项，就是系统的默认编码，一般是GBK，这种情况下用第一段代码解析是没有问题的，
JAVA打包后读取自身JAR中的文件
标签： 分类：Computer and I 杂谈 在编写完Java程序后，打包成Jar时发布，会发现找不到Jar文件中的图片和文本文件，其原因是程序中载入图片或文本文件时，使用了以当前工作路径为基准的方式来指定文件和路径。这与用户运行Jar包时的当前工作路径并不一致。问题分析： 例如：以Windows为例说明，以下是开发项目“AAA”的部分代码，开发和调试时的根路径为D:\aaa，这样程序运行时当前路径为"D:\aaa"，大家可以用System.getProperty("user.dir")方法求证当前用户工作路径。 //下面代码使用了基于当前工作路径的方式指定了文件对象 File imageFile = new File("/images/sample.gif"); ImageIcon imageIcon = new ImageIcon(File.toURI); File iniFile = new File("/conf.ini"); FileInputStream fileInputStream = new FileInputStream(iniFile.toU RI); 以上的代码应用绝对路径信息指定了文件对象，在开发和调试期（未打包前），是没有问题的，但在打包后，由于所有图片文件和文本文件都将打包到Jar文件中，由于System中的"user.dir"属性发生了变化，会造成用绝对路径的方式无法找到Jar文件中包含路径和文件。例如大家将上面的项目“AAA”中的所有类文件、图片文件和文本文件等打包为E:\aaa.jar文件并发布，在用户执行该aaa.jar中的程序时，当前路径取决于用户运行该程序的当前路径。 例如: 在“E:\”目录下运行该程序： E:\> java -jar aaa.jar 此时用户的当前路径（System的user.dir属性）是“E:\”，而非开发者所期望的“E:\aaa”，所以会按以下路径来搜索文件： E:\images\sample.gif E:\conf.ini 但是所有的图片和文本文件包含在E:\aaa.jar文件中，所以会致使程序无法正常运行。 问题解决： 为了解决上述问题，推荐采用Java本身以类为基准的路径搜索方式。 例如： /* *以下代码采用了以当前类为基准的路径指定方式。下面这行代码在运行时，会 *在jar文件中的根路径，搜索程序中用到的文件。 Reader reader =new InputStreamReader( getClass().getResourceAsStream("/image/Environment.ini")); ImageIcon i=new ImageIcon(getClass().getResource("/image/b1.gif")); 以上两行代码采用了下面两条Java语句： getClass().getResourceAsStream("FileName");
java IO读写文件
Java编程中的读写 读 一：Scanner 读取数据 import java.io.*; import java.util.Scanner; //获取Scanner类 public class Text3{ public static void main(String[] args){ try{ File f=new File("D:\\学习\\java\\1.txt"); String s=""; StringBuffer str=new StringBuffer(""); Scanner c=new Scanner(f); //通过Scanner类读取文件信息并输出while(c.hasNextLine()){ //c.hasNextLine() 判断读取行是否为空s=c.nextLine(); //按行读取目标文本 str.append(s); str.append("\n"); } System.out.print(str); }catch(IOException e){} } } 二：FileReaderBufferedReader读取数据（字符） 代码重点：FileReader -- 直接以字符形式读取文件数据 BufferedReader -- 处理流，读取字符 //缓冲流输出文本内容 import java.io.*; import java.io.BufferedReader.*; public class Text2{ public static void main(String[] args){ try{ File f=new File("D:\\学习\\java\\1.txt"); FileReader in=new FileReader(f); BufferedReader r=new BufferedReader(in); String s=""; StringBuffer str=new StringBuffer(""); while((s=r.readLine())!=null){ str.append(s);
java.io的几种读写文件的方式
一、java.io的几种读写文件的方式 1、InputStream、OutputStream（字节流） //读取文件(字节流) FileInputStream in=new FileInputStream("d:\\1.txt"); //写入相应的文件 FileOutputStream out=new FileOutputStream("d:\\2.txt"); //读取数据 //一次性取多少字节 byte[]bytes=new byte[2048]; //接受读取的内容(n就代表的相关数据，只不过是数字的形式) int n=-1; //循环取出数据 while((n=in.read(bytes,0,bytes.length))!=-1){ //转换成字符串 String str=new String(bytes,0,n,"UTF-8");#这里可以实现字节到字符串的转换，比较实用System.out.println(str); //写入相关文件 out.write(bytes,0,n); //清除缓存向文件写入数据 out.flush(); } //关闭流 in.close(); out.close(); 2、BufferedInputStream、BufferedOutputStream（缓存字节流）使用方式和字节流差不多，但是效率更高（推荐使用 //读取文件(缓存字节流) BufferedInputStream in=new BufferedInputStream(new FileInputStream("d:\\1.txt")); //写入相应的文件 BufferedOutputStream out=new BufferedOutputStream(new FileOutputStream("d:\\2.txt")); //读取数据 //一次性取多少字节 byte[]bytes=new byte[2048]; //接受读取的内容(n就代表的相关数据，只不过是数字的形式) int n=-1; //循环取出数据
Java读写Excel文件中数据的简便方法(附代码)
Java读写Excel文件中数据的简便方法 Java开发项目中经常会碰到处理Excel文件中数据的情况，这里通过一个例子来看一下实现方法：从Excel文件orders.xls中读取订单信息，从中找出2010年1月1日（含）之后，并且SELLERID等于18的订单。找到的数据写入order_result.xls文件。 Excel文件orders.xls的内容如下： ORDERID CLIE NT SE LLERID AMOUNT ORDERDATE 1 UJRNP 17 39 2 2008/11/2 15:28 2 SJCH 6 4802 2008/11/9 15:28 3 UJRNP 16 13500 2008/11/5 15:28 4 P WQ 9 26100 2008/11/8 15:28 5 P WQ 11 4410 2008/11/12 15:28 6 HANAR 18 6174 2008/11/ 7 15:28 7 E GU 2 17800 2008/11/6 15:28 8 VILJX 7 2156 2008/11/9 15:28 9 JAYB 14 17400 2008/11/12 15:28 10 JAXE 19 19200 2008/11/12 15:28 11 SJCH 7 13700 2008/11/10 15:28 12 QUICK 11 21200 2008/11/13 15:28 13 HL 12 21400 2008/11/21 15:28 14 JAYB 1 7644 2008/11/16 15:28 15 MIP 16 3234 2008/11/19 15:28 16 AYW YN 4 6566 2008/11/21 15:28 … Java程序的编写思路是 1、从Excel文件逐行读入数据保存到List对象sourceList中。 2、遍历List对象sourceList，如果满足条件就保存到结果List对象resultList中。 3、遍历reslutList，逐行保存到输出Excel文件中。 其中包含一些处理不同数据类型的语句，具体代码如下： public static void myExcel() throws Exception { //读excel数据 HSSFWorkbook workbook= newHSSFWorkbook(new FileInputStream(new File("d:/file/orders.xls"))); Sheet sheet=workbook.getSheetAt(0);//读取第一个sheet List