① java怎么直接在内存中读写对象
Java出现的目的就是为了防止对内存的直接操作，所以正常情况下是不必要对内存直接进行读写的。
如果你需要的只是在内存中开辟出一块区域，读写一些自定义的内容，可以用byte[]来实现。
如果你真的需要读取或者修改内存块，java中的unsafe类可以帮助你实现一些功能，但是这是不建议用的，因为它可能导致java虚拟机出错。包含unsafe的java代码也不是跨平台的。
② java实现文件的读写，是叫啥
您好，你的问题，我之前好像也遇到过，以下是我原来的解决思路和方法，希望能帮助到你，若有错误，还望见谅！展开全部
Java.io包中包括许多类提供许多有关文件的各个方面操作。
1 输入输出抽象基类InputStream/OutputStream ，实现文件内容操作的基本功能函数read()、 write()、close()、skip()等；一般都是创建出其派生类对象（完成指定的特殊功能）来实现文件读写。在文件读写的编程过程中主要应该注意异常处理的技术。
2 FileInputStream/FileOutputStream：
用于本地文件读写（二进制格式读写并且是顺序读写，读和写要分别创建出不同的文件流对象）；
本地文件读写编程的基本过程为：
① 生成文件流对象（对文件读操作时应该为FileInputStream类，而文件写应该为FileOutputStream类）；
② 调用FileInputStream或FileOutputStream类中的功能函数如read()、write(int b)等）读写文件内容；
③ 关闭文件（close()）。
3 PipedInputStream/PipedOutputStream：
用于管道输入输出（将一个程序或一个线程的输出结果直接连接到另一个程序或一个线程的输入端口，实现两者数据直接传送。操作时需要连结）；
4管道的连接：
方法之一是通过构造函数直接将某一个程序的输出作为另一个程序的输入，在定义对象时指明目标管道对象
PipedInputStream pInput=new PipedInputStream();
PipedOutputStream pOutput= new PipedOutputStream(pInput);
方法之二是利用双方类中的任一个成员函数 connect()相连接
PipedInputStream pInput=new PipedInputStream();
PipedOutputStream pOutput= new PipedOutputStream();
pinput.connect(pOutput);
5 管道的输入与输出：
输出管道对象调用write()成员函数输出数据（即向管道的输入端发送数据）；而输入管道对象调用read()成员函数可以读起数据（即从输出管道中获得数据）。这主要是借助系统所提供的缓冲机制来实现的。
6随机文件读写：
RandomAccessFile类（它直接继承于Object类而非InputStream/OutputStream类），从而可以实现读写文件中任何位置中的数据（只需要改变文件的读写位置的指针）。
随机文件读写编程的基本过程为：
① 生成流对象并且指明读写类型；
② 移动读写位置；
③ 读写文件内容；
④ 关闭文件。
七里河团队答疑助人,希望我的回答对你有所帮助非常感谢您的耐心观看，如有帮助请采纳，祝生活愉快！谢谢！
③ JAVA IO 对象的读写问题
java序列化
2008-03-10 10:37
1、序列化是干什么的？
简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
2、什么情况下需要序列化
a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；
3、当对一个对象实现序列化时，究竟发生了什么？
在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance ariable）比如：
java 代码Foo myFoo = new Foo();
myFoo .setWidth(37);
myFoo.setHeight(70);
当 通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（37，70）都被保存到foo.ser文件中，这样以后又可以把它 从文件中读出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对 象。
java 代码FileOutputStream fs = new FileOutputStream("foo.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(myFoo);
4、实现序列化（保存到一个文件）的步骤
a）Make a FileOutputStream java 代码FileOutputStream fs = new FileOutputStream("foo.ser");
b）Make a ObjectOutputStream
java 代码ObjectOutputStream os = new ObjectOutputStream(fs);
c）write the object
java 代码os.writeObject(myObject1);
os.writeObject(myObject2);
os.writeObject(myObject3);
d) close the ObjectOutputStream
java 代码os.close();
5、举例说明
java 代码import java.io.*;
public class Box implements Serializable
{
private int width;
private int height;
public void setWidth(int width){
this.width = width;
}
public void setHeight(int height){
this.height = height;
}
public static void main(String[] args){
Box myBox = new Box();
myBox.setWidth(50);
myBox.setHeight(30);
try{
FileOutputStream fs = new FileOutputStream("foo.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(myBox);
os.close();
}catch(Exception ex){
ex.printStackTrace();
}
}
}
//读取的代码类似这样的
FileInputStream istream = new FileInputStream("foo.ser"); // 输入流
ObjectInputStream pr = new ObjectInputStream(istream); // 绑定
Box myBox2 = (Box)pr.readObject(); // 读入序列化的类
istream.close();
6、相关注意事项
a）序列化时，只对对象的状态进行保存，而不管对象的方法；
b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
d）并非所有的对象都可以序列化，,至于为什么不可以，有很多原因了,比如：
1.安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输 等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
2. 资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分 配，而且，也是没有必要这样实现。
④ Java文件读写
实用的模糊（通配符）文件查找程序
1 import java.io.File;
2 import java.util.regex.Matcher;
3 import java.util.regex.Pattern;
4 import java.util.ArrayList;
5
6 /** *//**
7 * <p>Title: FileService </p> 8* <p>Description: 获取文件 </p> 9* <p>Copyright: Copyright (c) 2007</p>
10* <p>Company: </p>
11* @author not attributable
12* @version 1.0
13*/
14public class FileService {
15 public FileService() {
16 }
17
18 /** *//**
19 * 在本文件夹下查找
20 * @param s String 文件名
21 * @return File[] 找到的文件
22 */
23 public static File[] getFiles(String s)
24 {
25 return getFiles("./",s);
26 }
27
28 /** *//**
29 * 获取文件
30 * 可以根据正则表达式查找
31 * @param dir String 文件夹名称
32 * @param s String 查找文件名，可带*.?进行模糊查询
33 * @return File[] 找到的文件
34 */
35 public static File[] getFiles(String dir,String s) {
36 //开始的文件夹
37 File file = new File(dir);
38
39 s = s.replace('.', '#');
40 s = s.replaceAll("#", "\\\\.");
⑤ JAVA中如何实现文件读写对象急吖
java中引进了I/O包用于对文件的处理，你说的文件处理对象是file类，若要对其进行输入输出处理的话，需要进行如下几步：1 创建文件对象：File file1=new File（"文件目录"）；
2 用这个文件对像创建文件读写对象：FileInputStream inputstream=new FileInputStream （file1）；
这是文件读对象，对应的写对象就是把FileInputStream改成FileOutputStream就可以，
希望能帮上你！！
⑥ Java 如何对文件进行多个Object对象流的读写操作
思路：把已经序列化的对象存入容器（如LinkedList<?>）中，然后用ObjectInputStream和ObjectOutputStream对这个实例化的LinkedList<?>对象进行读写。测试主程序：/** * @Title: FileRW.java * @Package com.file * @Description: 文件、文件夹的创建、写入练习。读写是使用对象流实现。 * @author 慢跑学Android * @date 2011-11-19 下午03:53:01 * @version V1.0 */ package com.file; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.LinkedList; public class FileRW { private String dirPath; private String filename; public static void main(String[] args) { String path = "C:\\晓声"; String fileName = "test.txt"; FileRW fileRW = new FileRW(path, fileName); LinkedList<TestMessage> msgOut = new LinkedList<TestMessage>(); LinkedList<TestMessage> msgIn = null; msgOut.add(new TestMessage("柯南", "偶像")); msgOut.add(new TestMessage("卡卡西", "好样的")); msgOut.add(new TestMessage("Android", "Android")); msgOut.add(new TestMessage("哈哈", "测试下喔")); fileRW.writeObject(path, fileName, msgOut); msgIn = fileRW.readObject(path,fileName); for(TestMessage temp:msgIn) { System.out.println(temp.getName() + temp.getData()); } } public FileRW(String dirPath, String filename) { this.dirPath = dirPath; this.filename = filename; if (creatDir()) { creatFile(); } } private boolean creatDir() { if (null != dirPath) { File path = new File(dirPath); if (path.exists()) { return true; } if (true == path.mkdirs() ) { return true; } } return false; } private void creatFile() { if (null != filename) { File file = new File(dirPath, filename); if (false == file.exists()) { try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } } } /** * @Title: writeObject * @Description: Write a object to a file. * @param path the directory of the target file * @param filename the name of the target file * @param msg the type of the object * @return void * @throws */ private void writeObject(String path, String filename, LinkedList<TestMessage> msg) { File file = new File(path, filename); if (false == file.isFile()) { return ; } try { // The value "false" for FileOutputStream means that overwrite this file, // if it is "true",append the new data to this file. ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file,false)); oos.writeObject(msg); oos.flush(); oos.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /** * @Title: readObject * @Description: Read a object from a file. * @param path the directory of the target file * @param filename the name of the target file * @return LinkedList<TestMessage> * @throws */ @SuppressWarnings("unchecked") private LinkedList<TestMessage> readObject(String path, String filename) { File file = new File(path, filename); ObjectInputStream ois = null; LinkedList<TestMessage> msgAll = null; try { ois = new ObjectInputStream(new FileInputStream(file)); try { msgAll = (LinkedList<TestMessage>)ois.readObject(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { ois.close(); } catch (IOException e) { e.printStackTrace(); } } return msgAll; } } 测试程序中的消息包定义：/** * @Title: TestMessage.java * @Package com.file * @Description: FileRW的消息流 * @author 慢跑学Android * @date 2011-11-19 下午04:35:11 * @version V1.0 */ package com.file; public class TestMessage implements java.io.Serializable { private String name; private String data; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getData() { return data; } public void setData(String data) { this.data = data; } public TestMessage(String name, String msg) { this.name = name; data = msg; } } 程序运行结果：参考资料：ObjectInputStream类和ObjectOutputStream类的使用
⑦ java中用流对象去读写文件，读写完毕，调用流对象的close方法后，还用将流对象置为null吗
先判断流对象是否为空，然后关闭流对象就可以了，没必要设置为空，流所占的资源已经被释放了。