⑴ java如何將一個EXCEL文件作為二進制文件存入資料庫,再把它讀取打開
在資料庫設一個BLOB類型的欄位,然後把Excel文件保存進去.
其實保存什麼文件都可以.不一定要Excel的.
這方法通用,隨便在網路輸入"java blob"就可以找到很多方法了.
⑵ 請問後綴名為java和class的文件該用什麼軟體打開
.java後綴的文件最快捷簡單的打開方式就是用計事本；其它的可以用Ultraedite,netbeans,jcreate,eclipse等有關的支持java的工具;而.class文件後綴的文件是.java文件編譯後得到的一個二進制文件,是由java虛擬機來運行的,打開你也看不懂.
⑶ 怎樣用Java讀寫二進制文件
import java.util.*;
import java.io.*;
class SmallFile {
static final int HEADLEN = 24; //頭總長度
byte[] fileName = new byte[16]; //列表文件名1: 長度128 想把它讀到char[]里 它的編碼方式不是Unicode。在不確定編碼方式的時候，最好直接用byte[]來存放
int offset; //列表文件地址1: 長度32 想把它讀到int里
int length = -1; //列表文件長度1: 長度32 想把它讀到int里
byte[] content;
public SmallFile() {
}
public SmallFile(byte[] fn, byte[] content) {
Arrays.fill(fileName, (byte) 0);
if (fn != null) {
if (fn.length <= 16) {
System.array(fn, 0, fileName, 0, fn.length);
}
else {
System.array(fn, 0, fileName, 0, 16);
}
}
this.content = content;
if (content != null) {
this.length = content.length;
}
else {
this.length = -1;
}
}
}
public class ReadBinary {
static final int HEADLEN = 8; //頭總長度
private String filename;
private byte[] filehead = new byte[4]; //文件頭: 長度32 想把它讀到char[]里 它的編碼方式不是Unicode
private int filecount = -1; //列表長度: 長度32 想把它讀到int里 假設他是3 就會有3個列表文件名
private List<SmallFile> files = null;
public void setFilehead(byte[] fh) {
if (fh == null)
return;
Arrays.fill(filehead, (byte) 0);
if (fh.length <= 4) {
System.array(fh, 0, filehead, 0, fh.length);
}
else {
System.array(fh, 0, filehead, 0, 4);
}
}
public ReadBinary(String filename) {
try {
readFromFile(filename);
}
catch (Exception ex) {
System.out.println(ex.getMessage());
System.out.println("在載入數據文件時失敗，因此視同為新建一個數據文件！");
this.filename = filename;
Arrays.fill(filehead, (byte) 0);
filecount = 0;
files = new ArrayList<SmallFile> ();
}
}
public void readFromFile(String filename) throws Exception {
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(
filename));
this.filename = filename;
DataInputStream in = new DataInputStream(bin);
in.read(filehead); //文件頭: 長度32 想把它讀到char[]里 它的編碼方式不是Unicode
filecount = in.readInt(); //列表長度: 長度32 想把它讀到int里 假設他是3 就會有3個列表文件名
if (files == null) {
files = new ArrayList<SmallFile> ();
}
else {
files.clear();
}
for (int i = 0; i < filecount; i++) {
SmallFile file = new SmallFile();
in.read(file.fileName);
file.offset = in.readInt(); //列表文件地址1: 長度32 想把它讀到int里
file.length = in.readInt(); //列表文件長度1: 長度32 想把它讀到int里
files.add(file);
}
}
public void writeToFile() throws Exception {
String temp = filename + ".tmp"; //臨時文件
boolean exists = false;
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(filename, "r"); //文件存在則從文件讀入
exists = true;
}
catch (Exception ex) {
System.out.println("文件不存在，因此啟用內存寫入模式");
}
if (filecount != files.size()) {
throw new Exception("怪事，居然不相同？？");
}
DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new
FileOutputStream(temp)));
//1、寫總文件頭
out.write(filehead);
out.writeInt(filecount);
//2、寫列表頭
int sumlength = 0;
for (int i = 0; i < files.size(); i++) {
SmallFile file = files.get(i);
out.write(file.fileName);
if (file.length < 0) {
throw new Exception("怪事，文件長度怎麼可能小於0？");
}
else {
out.writeInt(ReadBinary.HEADLEN + SmallFile.HEADLEN * filecount +
sumlength);
sumlength += file.length;
out.writeInt(file.length);
}
}
//3、寫文件內容
for (int i = 0; i < files.size(); i++) {
SmallFile file = files.get(i);
if (file.content != null && (file.length == file.content.length)) {
out.write(file.content);
}
else if (exists) {
raf.seek(file.offset);
byte[] b = new byte[file.length];
raf.read(b);
System.out.println("b:" + new String(b));
out.write(b);
}
else {
throw new Exception("怪事，又不能從內存讀，又不能從文件讀。這活沒法幹了!");
}
}
out.close();
if (raf != null) {
raf.close();
raf = null;
}
System.gc();
//把原先的文件刪除
File f = new File(filename);
f.delete();
//再把臨時文件改名到正式文件
File f2 = new File(temp);
f2.renameTo(f);
}
public void addFile(SmallFile file) {
if (files != null) {
filecount++;
files.add(file);
}
}
public static void test1(){
ReadBinary rb = new ReadBinary("f:\\temp\\rb.dat");
rb.setFilehead("".getBytes());
SmallFile f = new SmallFile("第1個文件".getBytes(), "第1個文件的內容".getBytes());
rb.addFile(f);
try {
rb.writeToFile();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void test2(){
ReadBinary rb = new ReadBinary("f:\\temp\\rb.dat");
rb.setFilehead("HEA".getBytes());
SmallFile f = new SmallFile("第2個文件".getBytes(), "第2個文件的內容".getBytes());
rb.addFile(f);
try {
rb.writeToFile();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) {
//test1();
test2();
}
}
⑷ 請教，怎麼用JAVA來讀取二進制文件
用FileInputStream讀取文件，然後BufferedInputStream來裝流，最後用read方法讀出位元組數組用
⑸ java寫二進制文件，不能直接編輯，該怎麼操作
一直以來都在用java編程，以前在Java寫一些二進制格式的文件，就用DataOutputStream很方法，例如它的writeInt，writeLong等，我今天在看一些代碼的時候發現DataOutputStream在處理多位元組的數字的時候，使用的是BIG_ENDIAN(即將高位的位元組放在內存地址的低地址上)，相應的DataInputStream的讀取方式也使用的是BIG_ENDIAN。
這樣就引出一個問題，如果我是用Java之外的語言，比如C語言讀取由DataOutputStream生成的文件，而平台正好是LITTLE_ENDIAN(用得很廣泛的x86的系統都是LITTLE＿ENDIAN)，很可能會造成數據錯誤，除非在C程序中自己重新按照BIG＿ENDIAN的格式組裝int或者long.
這樣我們需要在寫文件的時候就按照平台的位元組順來寫，而ByteBuffer已經考慮到了這一點。
java.nio.ByteBuffer默認是BIG＿ENDIAN(這可能和ByteBuffer主要用來做網路通訊有關)，但是這個值是可以修改的。
比較使用DataOutputStream和ByteBuffer寫文件的差異:
public static void main(String[] args) throws IOException {
int _int = 12345678;
ByteBuffer _nbuffer = ByteBuffer.allocate(4);
_nbuffer.order(ByteOrder.nativeOrder()); //將新建的ByteBuffer設置為本機的位元組順
_nbuffer.putInt(_int);
_nbuffer.flip();
FileOutputStream _fou = new FileOutputStream("test_dout.data");
FileOutputStream _nfou = new FileOutputStream("test_nbuf.data");
DataOutputStream _dou = new DataOutputStream(_fou);
_dou.writeInt(_int);
_dou.close();
_nfou.write(_nbuffer.array());
_nfou.close();
System.out.println(ByteOrder.nativeOrder());
}
執行上面的代碼生成兩個文件：
test_dout.data － 使用DataOutputStream生成的BIG_ENDIAN文件，
test_nbuf.data － 使用ByteBuffer生成的主機位元組順的文件（此處的主機位元組順為LITTLE_ENDIAN）
使用下面的C程序分別讀取這兩個文件:
#include <stdio.h>
int read_file(char* file);
main()
{
char* dout = "test_dout.data";
char* nbuf = "test_nbuf.data";
printf("data in %s:%d\n",dout,read_file(dout));
printf("data in %s:%d\n",nbuf,read_file(nbuf));
}
int read_file(char* file)
{
FILE *fp;
int dat[1];
fp=fopen(file, "rb");/*打開一個二進制文件只讀*/
fread(dat, sizeof(int), 1, fp);
fclose(fp);
return dat[0];
}
編譯並執行:
gcc a.c
./a.out
data in test_dout.data:1315027968
data in test_nbuf.data:12345678
上面的C程序從test_dout.data取得的int數值是錯誤的，而從test_nbuf.data是正確的。
ByteBuffer不方便的地方在於它的大小不能自動擴展，但是也是可以解決的，比如MINA自己的ByteBuffer就支持自成擴展。
Java的生成二進制數據文件，應該要考慮一下位元組順的問題，以適應一些特殊的需求，比如多語言平台編程的情況。
⑹ 請教，怎麼用JAVA來讀取二進制文件並輸出文件內容
Java讀取二進制文件，以位元組為單位進行讀取，還可讀取圖片、音樂文件、視頻文件等，
在Java中，提供了四種類來對文件進行操作，分別是InputStream OutputStream Reader Writer ，前兩種是對位元組流的操作，後兩種則是對字元流的操作。
示例代碼如下：
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;
}
⑺ java讀取二進制文件
思路：按照位元組讀取文件到緩沖，然後對文件內容進行處理。
代碼如下：
publicstaticvoidreadFile()throwsIOException{
RandomAccessFilef=newRandomAccessFile("test.txt","r");
byte[]b=newbyte[(int)f.length()];
//將文件按照位元組方式讀入到位元組緩存中
f.read(b);
//將位元組轉換為utf-8格式的字元串
Stringinput=newString(b,"utf-8");
//可以匹配到所有的數字
Patternpattern=Pattern.compile("\d+(\.\d+)?");
Matchermatch=pattern.matcher(input);
while(match.find()){
//match.group(0)即為你想獲取的數據
System.out.println(match.group(0));
}
f.close();
}
⑻ 怎樣用java 把一個bin二進制圖片文件打開代碼呢怎麼寫
讀：
BufferedInputStream fis = new BufferedInputStream(
new FileInputStream(sourceFile));
byte[] b = new byte[(int) sourceFileLength];
while (fis.read(b) != -1);
fis.close();
return b;
寫：
BufferedOutputStream fos = new BufferedOutputStream(
new FileOutputStream(targetFile));
for (int i = 0; i < bytes.length - 1; i++) {
/*do something if any*/
fos.write(content[i]);
}
fos.write(content[content.length - 1]); // 寫入最後一個位元組
fos.flush();
fos.close();
請自行增加異常處理。
⑼ 如何用Java或C語言解析二進制文件為文本文件
在學習C語言fopen()函數後，知道它的第二個參數是標志字元串。如果字元串中出現'b'，則表明是以打開二進制(binary)文件，否則是打開文本文件。
那麼什麼是文本文件，什麼是二進制文件呢？
從文件編碼的方式來看，文件可分為ASCII碼文件和二進制碼文件兩種。
ASCII文件也稱為文本文件，這種文件在磁碟中存放時每個字元對應一個位元組，用於存放對應的ASCII碼。例如，數5678的存儲形式為：
ASC碼： 00110101 00110110 00110111 00111000
↓ ↓↓ ↓
十進制碼： 5678
共佔用4個位元組。ASCII碼文件可在屏幕上按字元顯示， 例如源程序文件就是ASCII文件，用DOS命令TYPE可顯示文件的內容。 由於是按字元顯示，因此能讀懂文件內容。
二進制文件是按二進制的編碼方式來存放文件的。例如，數5678的存儲形式為：00010110 00101110隻佔二個位元組。二進制文件雖然也可在屏幕上顯示，但其內容無法讀懂。C系統在處理這些文件時，並不區分類型，都看成是字元流，按位元組進行處理。輸入輸出字元流的開始和結束只由程序控制而不受物理符號(如回車符)的控制。因此也把這種文件稱作「流式文件」。
文本文件與二進制文件的區別在系統存儲上它們實際上並沒有什麼區別，都是以二進制的方式存儲於硬碟上。之所以分二進制文件和文本文件，主要是邏輯上的區分，文本文件更人為可讀而已。站在編程的角度看，文本文件是基於字元編碼過後的，比如常見的就有ascii編碼，gbk編碼，unicode編碼等，文本工具直接打開人為可讀。而二進制文件是基於值的編碼，這個值到底是什麼，完全可自定義，所以可以說二進制文件是一種特殊編碼的文件。如果用java編程，可能就根本沒遇到過以二進制打開和文本文件打開這兩種方式。java裡面有字元流和位元組流，字元流是對位元組流的封裝，有編碼解碼，而位元組流操作的則是byte數組，所以更容易理解。python的文件讀寫方式則更貼近C。因為python和java他們底層都是C，所以很有必要弄清C的讀寫文件方式。
在Windows和DOS系統中，狹義的文本文件是指擴展名為txt的文件。實際上，那些沒有規定格式的，由可理解的的ASCII以及其他編碼文字組成的文件都是文本文件，如C源程序文件，HTML超文本，XML。除此之外的其他文件都是二進制文件，如Word文件DOC，圖象格式文件JPG。
實際上，fopen()的 b 標志不但可以打開二進制文件，還可以打開文本文件，同樣，不帶 b 標志也可以打開文本文件。
既然這樣，為什麼還要區分兩種打開方式呢？
因為這兩種方式在讀寫文件時的操作是不一樣的。
二進制方式很簡單，讀文件時，會原封不動的讀出文件的全部內容，寫的時候，也是把內存緩沖區的內容原封不動的寫到文件中。
而文本方式就不一樣了，在寫文件時，會將換行符號CRLF(0x0D 0x0A)全部轉換成單個的0x0A，並且當遇到結束符CTRLZ(0x1A)時，就認為文件已經結束。相應的，寫文件時，會將所有的0x0A換成0x0D0x0A。
所以，若使用文本方式打開二進制文件時，就很容易出現文件讀不完整，或內容不對的錯誤。即使是用文本方式打開文本文件，也要謹慎使用，比如復制文件，就不應該使用文本方式。
要特別注意的是，上面這樣的說法僅適用於DOS和Windows系統。在Unix和其他一些系統中，沒有文本方式和二進制方式的區分，使不使用'b'標志都是一樣的。這是由於不同操作系統對文本文件換行符的定義，和C語言中換行符的定義有所不同而造成的。
如上文已提到，DOS和Windows系統使用CRLF(0x0D 0x0A)即\r\n雙位元組作為文本文件換行符，而Unix文本文件的換行符只有一個位元組LF(0x0A)為。在C語言中，也是以LF即'\n'為換行符。
由於DOS/Windows定義的換行符和C語言的不一致，C語言的標准輸入輸出函數適行讀寫文本文件時，就適行了CRLF->LF的轉換。而Unix的定義和C語言的是一樣的，就不必轉換了。
那麼，為什麼會有定義不一致的情況呢，這純屬歷史原因。當初C是在Unix上發展的，對換行的定義自然就一樣了。其後C被引入到DOS系統，為了使原有的C程序能不加修改的讀寫DOS的文本文件，所以就在文件讀寫上做了修改。隨著DOS/Windows成為主流平台，這個當初為了兼容而做的修改給眾多的C語言開發者添了這樣一個小小的麻煩。
所以，二進制和文本模式的區別就在於對於換行符和一些非可見字元上面的轉化，所以安全起見，是使用二進制讀取會比較安全一些。
⑽ JAVA中讀取文件（二進制，字元）內容的幾種方
JAVA中讀取文件內容的方法有很多，比如按位元組讀取文件內容，按字元讀取文件內容，按行讀取文件內容，隨機讀取文件內容等方法，本文就以上方法的具體實現給出代碼，需要的可以直接復制使用
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);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以字元為單位讀取文件，常用於讀文本，數字等類型的文件
*/
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下，\r\n這兩個字元在一起時，表示一個換行。
// 但如果這兩個字元分開顯示時，會換兩次行。
// 因此，屏蔽掉\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) {
}
}
}
}
/**
* 以行為單位讀取文件，常用於讀面向行的格式化文件
*/
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) {
}
}
}
}
/**
* 隨機讀取文件內容
*/
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) {
}
}
}
}
/**
* 顯示輸入流中還剩的位元組數
*/
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);
}
}