Java把double数据写入文件中
public class ReadOrWriteObject {
private FileInputStream fileIns =//文件输入流
private FileOutputStream
fileOts =//文件输出流
private ObjectInputStream
objectIns =//对象输入流
private ObjectOutputStream objectOts =//对象输出流
private String fileName =//待处理的文件名
public static Boolean FileRead =
public static Boolean FileWrite =
* @param fileName:文件名
public ReadOrWriteObject(String fileName){
this.fileName = fileN
* 创建对象之后，首先必须以某种方式打开文件，如读的方式，或者写的方式
* @param fileName: The name of the file.
* @param bool: Whether the file read or write.如 FileRead or FileWrite
public Boolean openFile(Boolean bool){
if(bool)//if bool is true,the file is read.
this.fileIns = new FileInputStream(this.fileName);
this.objectIns = new ObjectInputStream(fileIns);
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
this.fileOts = new FileOutputStream(this.fileName);
this.objectOts = new ObjectOutputStream(this.fileOts);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
* 关闭文件流，对象流
* @return 成功关闭返回true
public Boolean closeFile(){
if(null !=this.fileIns){
this.objectIns.close();
this.fileIns.close() ;
objectIns =
} catch (IOException e) {
e.printStackTrace();
if(null != this.fileOts){
this.objectOts.close();
this.fileOts.close();
objectOts =
} catch (IOException e) {
e.printStackTrace();
* 刷新缓冲区
public void flush(){
this.objectOts.flush();
} catch (IOException e) {
e.printStackTrace();
* @param d 需要写入文件的double数据
* @return 写入成功则返回true，否则返回false
public Boolean writeDouble(double d){
if(this.objectOts!=null){
this.objectOts.writeDouble(d);
} catch (IOException e) {
e.printStackTrace();
* 读取double型数据
* @return 返回无穷小为false
public double readDouble(){
double d=0;
if(this.objectIns!=null){
d = this.objectIns.readDouble();//读取到文件末尾，被EOFException捕获
} catch (EOFException e) {
this.closeFile();
return Double.MIN_NORMAL;
} catch (IOException e) {
this.closeFile();
e.printStackTrace();
return Double.MIN_NORMAL;
* @param args
public static void main(String[] args) {
//写入Double数据
String file = "F:\\1.txt";
ReadOrWriteObject rOd = new ReadOrWriteObject(file);
rOd.openFile(ReadOrWriteObject.FileWrite);
for(int i =0;i<1000;i++)
rOd.writeDouble(i);
rOd.flush();
rOd.closeFile();
//"-----分割线-----"
//读取Double数据
double d =0 ;
rOd.openFile(ReadOrWriteObject.FileRead);
while(true){
d = rOd.readDouble() ;
if(d == Double.MIN_NORMAL){//读取文件的终止符,双精度最小值，在文件中已经关闭了相关的流
System.out.println(d);
rOd.closeFile();Java 往数据库插入时间格式的数据 -
- ITeye博客
package org.interview.
import java.sql.C
import java.sql.DriverM
import java.sql.SQLE
import java.sql.S
import java.text.DateF
import java.text.SimpleDateF
import java.util.D
* 时间插入数据库的两种方式:
用java.sql.Date：将java.util.Date(),调用该类的getTime()方法，返回一个long类型的数据，作为sql.Date()的参数就可以插入
用格式化参数：SimpleDateFormat 的df.format()将时间转换成字符串插入进入
public class TestDate {
public static void main(String[] args) {
testDate1();
testDate2();
static void testDate1(){
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/test");
Statement stmt = conn.createStatement();
Date birthday1 = new Date();
java.sql.Date birthday = new java.sql.Date(birthday1.getTime());
String sql = "insert into testdate(name,birthday) values('fff'"+",'"+birthday+"')";
System.out.println(sql);
stmt.execute(sql);
} catch (ClassNotFoundException e) {
System.out.println("找不到类文件");
} catch (SQLException e) {
e.printStackTrace();
static void testDate2(){
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/test");
Statement stmt = conn.createStatement();
Date birthday1 = new Date();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String birthday = df.format(birthday1);
String sql = "insert into testdate(name,birthday) values('fff'"+",'"+birthday+"')";
System.out.println(sql);
stmt.execute(sql);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
System.out.println("找不到类文件");
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
Java-feifeiok
浏览: 16258 次
来自: 石家庄
这个问题的答案其实很简单，就是在struts.xml中把act ...java InputStream读取数据问题 - java小强 - ITeye博客
博客分类：
首先请查看一下JavaAPI，可以看到InputStream读取流有三个方法，分别为read()，read(byte[] b),read(byte[] b, int off, int len)。其中read()方法是一次读取一个字节，鬼都知道效率是非常低的。所以最好是使用后面两个方法。
例如以下代码：
* @param inStream
* @return 字节数组
* @throws Exception
public static byte[] readStream(InputStream inStream) throws Exception {
ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = -1;
while ((len = inStream.read(buffer)) != -1) {
outSteam.write(buffer, 0, len);
outSteam.close();
inStream.close();
return outSteam.toByteArray();
我们来测试一下：
public static void main(String[] args) {
File file = new File("C:\\ceshi.txt");
FileInputStream fin = new FileInputStream(file);
byte[] filebt = readStream(fin);
System.out.println(filebt.length);
} catch (Exception e) {
e.printStackTrace();
后台会打印这个文本的字节大小。看起来，这个是没有问题的。
关于InputStream类的available()方法这个方法的意思是返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。为什么需要这个方法？因为在一些网络应用中，数据流并不是一次性就能传递的，如果我们还是像上面那样去将这个流转换，会出问题的。我们来做一个例子，这是一个Socket编程的简单例子，具体Socket内容我会在后面文章中解释的。
首先编写两个类，一个用户初始化Socket服务，并且处理每个请求都有新的线程去处理，代码如下：
package com.
import java.net.*;
public class DstService {
public static void main(String[] args) {
// 启动监听端口 8001
ServerSocket ss = new ServerSocket(8001);
boolean bRunning =
while (bRunning) {
// 接收请求
Socket s = ss.accept();
// 将请求指定一个线程去执行
new Thread(new DstServiceImpl(s)).start();
} catch (Exception e) {
e.printStackTrace();
那么处理类我们也来看一下：
package com.
import java.io.*;
import java.net.*;
import com.util.*;
public class DstServiceImpl implements Runnable {
Socket socket =
public DstServiceImpl(Socket s) {
this.socket =
public void run() {
InputStream ips = socket.getInputStream();
OutputStream ops = socket.getOutputStream();
while (true) {
byte[] bt = StreamTool.readStream(ips);
String str = new String(bt);
System.out.println("主机收到信息：" + str);
String restr = "你好，主机已经收到信息！";
ops.write(restr.getBytes());
ops.flush();
} catch (Exception e) {
e.printStackTrace();
至于工具类，我就直接给代码了：
package com.
import java.io.*;
public class StreamTool {
public static void main(String[] args) {
File file = new File("C:\\ceshi.txt");
FileInputStream fin = new FileInputStream(file);
byte[] filebt = readStream(fin);
System.out.println(filebt.length);
} catch (Exception e) {
e.printStackTrace();
* @功能 读取流
* @param inStream
* @return 字节数组
* @throws Exception
public static byte[] readStream(InputStream inStream) throws Exception {
ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = -1;
while ((len = inStream.read(buffer)) != -1) {
outSteam.write(buffer, 0, len);
outSteam.close();
inStream.close();
return outSteam.toByteArray();
你可以直接运行这个类，会看到流被转换的效果。
我们来写一个Socket客户端测试一下：
package com.
import java.io.*;
import java.net.*;
import com.util.*;
public class DstClient {
public static void main(String[] args) {
Socket socket = new Socket("127.0.0.1", 8001);
// 开启保持活动状态的套接字
socket.setKeepAlive(true);
// 设置读取超时时间
socket.setSoTimeout(30 * 1000);
OutputStream ops = socket.getOutputStream();
String mess = "你好，我是崔素强！";
ops.write(mess.getBytes());
InputStream ips = socket.getInputStream();
byte[] rebyte = StreamTool.readStream(ips);
String remess = new String(rebyte);
System.out.println("收到主机消息：" + remess);
socket.close();
} catch (Exception e) {
e.printStackTrace();
先运行DstService，然后运行客户端，看效果。会发现，控制台没有任何输出。经过调试发现，因为请求死在了
while ((len = inStream.read(buffer)) != -1) {
这行代码上面。这就是在网络应用中会造成的后果。那么如何解决呢？有的人给出了如下代码：
int count = in.available();
byte[] b = new byte[count];
in.read(b);
可是在进行网络操作时往往出错，因为你调用available()方法时，对发发送的数据可能还没有到达，你得到的count是0。需要做如下修改，是我们的读取流方法改成如下：
* @功能 读取流
* @param inStream
* @return 字节数组
* @throws Exception
public static byte[] readStream(InputStream inStream) throws Exception {
int count = 0;
while (count == 0) {
count = inStream.available();
byte[] b = new byte[count];
inStream.read(b);
下面你在运行，会看到服务端和客户端都收到了消息。
关于InputStream.read(byte[] b)和InputStream.read(byte[] b,int off,int len)这两个方法都是用来从流里读取多个字节的，有经验的程序员就会发现，这两个方法经常 读取不到自己想要读取的个数的字节。比如第一个方法，程序员往往希望程序能读取到b.length个字节，而实际情况是，系统往往读取不了这么多。仔细阅读Java的API说明就发现了，这个方法 并不保证能读取这么多个字节，它只能保证最多读取这么多个字节(最少1个)。因此，如果要让程序读取count个字节，最好用以下代码：
int count = 100;
byte[] b = new byte[count];
int readCount = 0; // 已经成功读取的字节的个数
while (readCount & count) {
readCount += inStream.read(b, readCount, count - readCount);
这样就能保证读取100个字节，除非中途遇到IO异常或者到了数据流的结尾情况！
老规矩，最后是上传源代码！
请您到ITEYE看我的原创：
或支持我的个人博客，地址：
下载次数: 528
浏览 142892
public static byte[] readStream(InputStream inStream) throws Exception {& &&& int count = 0;& &&& while (count == 0) {& &&&&&&& count = inStream.available();& &&& }& &&& byte[] b = new byte[count];& &&& inStream.read(b);& &&&& }& 这段代码只能确保读到一段流吧，如果是分段发送的怎么办？----同问~请教博主是否存在此情况，以及应该如何处理~~谢谢
三个read 方法都是一个字节一个字节的读，后两个read方法里面是调用第一个read，效率似乎应该都一样。看了代码，后两个方法是封装了第一个方法，但是如果你自己写的话，估计会更慢。
楼主有个问题， 你把读数据改成public static byte[] readStream(InputStream inStream) throws Exception {& &&& int count = 0;& &&& while (count == 0) {& &&&&&&& count = inStream.available();& &&& }& &&& byte[] b = new byte[count];& &&& inStream.read(b);& &&&& }& 那你要在哪里写数据呢 ?拿到Output就可以写
windseamless 写道windseamless 写道public static byte[] readStream(InputStream inStream) throws Exception {
int count = 0;
while (count == 0) {
count = inStream.available();
byte[] b = new byte[count];
inStream.read(b);
& 如果是这样读取的话，比如在接受心跳数据的时候，发送信条时间间隔比较长的情况下，这个循环一直在执行，去、这样就会造成电脑非常卡windseamless 写道public static byte[] readStream(InputStream inStream) throws Exception {
int count = 0;
while (count == 0) {
count = inStream.available();
byte[] b = new byte[count];
inStream.read(b);
& 如果是这样读取的话，比如在接受心跳数据的时候，发送心跳时间间隔比较长的情况下，这个循环一直在执行，这样就会造成电脑非常卡你说的这个方法很好，这样的话就可以解决死循环问题确实应该增加个休眠
windseamless 写道public static byte[] readStream(InputStream inStream) throws Exception {
int count = 0;
while (count == 0) {
count = inStream.available();
byte[] b = new byte[count];
inStream.read(b);
& 如果是这样读取的话，比如在接受心跳数据的时候，发送信条时间间隔比较长的情况下，这个循环一直在执行，去、这样就会造成电脑非常卡windseamless 写道public static byte[] readStream(InputStream inStream) throws Exception {
int count = 0;
while (count == 0) {
count = inStream.available();
byte[] b = new byte[count];
inStream.read(b);
& 如果是这样读取的话，比如在接受心跳数据的时候，发送心跳时间间隔比较长的情况下，这个循环一直在执行，这样就会造成电脑非常卡你说的这个方法很好，这样的话就可以解决死循环问题
public static byte[] readStream(InputStream inStream) throws Exception {
int count = 0;
while (count == 0) {
count = inStream.available();
byte[] b = new byte[count];
inStream.read(b);
& 如果是这样读取的话，比如在接受心跳数据的时候，发送信条时间间隔比较长的情况下，这个循环一直在执行，去、这样就会造成电脑非常卡可以在里面加个Thread.sleep(200);，然后在定个变量，int k = 0，线程没休眠一次k++，直到k大于等于一个数值，比如15，就即3s内仍无数据，就咔嚓连接
public static byte[] readStream(InputStream inStream) throws Exception {
int count = 0;
while (count == 0) {
count = inStream.available();
byte[] b = new byte[count];
inStream.read(b);
& 如果是这样读取的话，比如在接受心跳数据的时候，发送信条时间间隔比较长的情况下，这个循环一直在执行，去、这样就会造成电脑非常卡windseamless 写道public static byte[] readStream(InputStream inStream) throws Exception {
int count = 0;
while (count == 0) {
count = inStream.available();
byte[] b = new byte[count];
inStream.read(b);
& 如果是这样读取的话，比如在接受心跳数据的时候，发送心跳时间间隔比较长的情况下，这个循环一直在执行，这样就会造成电脑非常卡
cuisuqiang 写道lsh009 写道cuisuqiang 写道lsh009 写道顶，最近在做socket连接，就是read inputstream 死锁了，谢谢你可以看看mina框架你好，服务器端用mina，客户端不要mina用普通的socket或者nio应该可以的吧？没有问题，如果你用mina，别人就必须用mina，那做C和C++的岂不是要死呵呵，确认一下，不然以后有什么问题会很麻烦，毕竟客户端不是我们这边做的，现在只做服务端，再问个问题额，接收到数据 我需要比较长时间处理数据，再返回，用mina需要自己实现多线程吗，还是mina本身实现了，不做多线程的话，后续来的数据，会卡住等待前一个数据处理完才处理吗？谢谢我建议你呢做个实验，在Mina收到数据时打印一条信息，然后长期休眠，然后再模拟发一条数据，看看能不能打印
lsh009 写道cuisuqiang 写道lsh009 写道顶，最近在做socket连接，就是read inputstream 死锁了，谢谢你可以看看mina框架你好，服务器端用mina，客户端不要mina用普通的socket或者nio应该可以的吧？没有问题，如果你用mina，别人就必须用mina，那做C和C++的岂不是要死呵呵，确认一下，不然以后有什么问题会很麻烦，毕竟客户端不是我们这边做的，现在只做服务端，再问个问题额，接收到数据 我需要比较长时间处理数据，再返回，用mina需要自己实现多线程吗，还是mina本身实现了，不做多线程的话，后续来的数据，会卡住等待前一个数据处理完才处理吗？谢谢
cuisuqiang 写道lsh009 写道顶，最近在做socket连接，就是read inputstream 死锁了，谢谢你可以看看mina框架你好，服务器端用mina，客户端不要mina用普通的socket或者nio应该可以的吧？没有问题，如果你用mina，别人就必须用mina，那做C和C++的岂不是要死
lsh009 写道顶，最近在做socket连接，就是read inputstream 死锁了，谢谢你可以看看mina框架你好，服务器端用mina，客户端不要mina用普通的socket或者nio应该可以的吧？
顶，最近在做socket连接，就是read inputstream 死锁了，谢谢你可以看看mina框架
& 上一页 1
cuisuqiang
浏览: 2602786 次
来自: 北京
浏览量：2400231
页面还是jsp，怎么能叫做Freemarker入门示例呢？小强 ...
学习了！ 用了这个方法，就不会阻塞了
用setField返回一些简单，重要的信息，不要保存太多的信息 ...
写道为什么我下载你的mypushlet.ra ...
为什么我下载你的mypushlet.rar 怎么出不来 报40 ...自己做了个程序，希望进行操作后将部分数据写入安装目录下的config.xml中。目前若程序在安装在非系统盘可以正常操作。
问：java是否可以获得对windows系统盘的写权限？代码如何....先谢过....
--感觉这问题应该很常见，怎么网上都搜不到信息.....
该问题被发起重新开启投票
投票剩余时间：
之前被关闭原因：
该问题被发起删除投票
投票剩余时间：
距离悬赏到期还有：
参与关闭投票者：
关闭原因：
该问题已经被锁定
锁定原因：（）
保护原因：避免来自新用户不合宜或无意义的致谢、跟帖答案。
该问题已成功删除，仅对您可见，其他人不能够查看。
不都一样么？你能在其它盘写入，C盘不也是一样的，都是IO操作
看你是用哪种方式操作数据的，如果系统盘受保护用下面的代码会报异常java.io.FileNotFoundException: c:\bbaacp.txt (拒绝访问。)
File file = new File("c:&#92;bbaacp.txt");System.out.println(file.createNewFile());file.setReadOnly();FileOutputStream os = new FileOutputStream(file);os.write("test".getBytes());
但如果用下面的代码则不会：
FileWriter file = new FileWriter("c:&#92;bbaacp.txt");file.write("test");file.flush();file.close();
你可以换一下操作数据的方式，java中提供了很多io的操作。
win8系统，程序不能方便的写入programe Files 这个文件夹
德问是一个专业的编程问答社区，请
后再提交答案
关注该问题的人
共被浏览 (2093) 次三、使用BufferedReader取得含空格的输入
//Scanner取得的输入以space, tab, enter 键为结束符，&&//要想取得包含space在内的输入，可以用java.io.BufferedReader类来实现&&//使用BufferedReader的readLine( )方法&&//必须要处理java.io.IOException异常&&BufferedReader br = new BufferedReader(new InputStreamReader(System.in ));&&//java.io.InputStreamReader继承了Reader类&&String read =&&System.out.print("输入数据：");&&try {&&&read = br.readLine();&&} catch (IOException e) {&&&e.printStackTrace();&&}&&System.out.println("输入数据："+read);&
学习在与持久！