javatar打包_java如何打包

A. linux如何更新java的classes版本可以用tar包吗tar包该怎么样打呢要写sh文件吗

你好，启动tomcat，将java项目放在tomcat的webapps文件夹下面，sh /bin/startup.sh就可以，它会自动解压缩。jar cvf xxx.war 命令打包项目。tar -czf是压缩命令，压缩文件用的。

B. java 怎么把多个jar打包成一个jar来使用

Java程序由多个类文件组成，这些类文件需要编译成多个“.class”二进制字节码文件才能运行，而一个稍大写的Java程序，编译后都会有非常多的“.class”文件，这样对于程序的发布非常的不方便。下面将介绍如何将Java程序的多个编译后的“.class”文件打包成一个可执行的JAR文件，这样将该JAR文件发布给用户就可以了。
1. Java程序打包成JAR文件
（1）在Eclipse的“包资源管理器”视图中找到要打包成JAR文件的项目。在项目名称上单击鼠标右键，在弹出的菜单中选择“导出”菜单项。在“导出”对话框中选择“Java”/“可运行的JAR文件”。
（2）在“可运行的JAR文件导出”向导对话框的“启动配置”下拉选择框中，选择“StudyJava-2.01”。这个下拉选择看中保存着运行过的启动配置，由于之前已经运行过StudyJava类，所以这个下拉选择框中可
以选择StudyJava类的启动配置。选项的“-2.01”后缀是启动配置所在的项目名称。然后在“导出目标”下拉选择框中输入保存打包后JAR文件的名称和位置，也可以通过单击右侧的“浏览按钮”选择指定的位置。
2. 在命令行运行JAR文件
现在的实例是在控制台中输出字符串信息。把它打包成JAR文件之后必须通过命令行方式运行，这样才可以在命令行中看到程序的输出结果。下面介绍一下具体运行方法。

（1）在windows系统中，单击“开始”/“运行”菜单项。

（2）在弹出的“运行”对话框中输入“CMD”命令。单击“确定”按钮。

（3）在CMD命令中，默认的操作位置是当前用户文件夹，由于打包的“StudyJava.jar”文件保存在C盘根目录，所以我们输入“cd\”命令，把操作文件夹切换到C盘根目录。然后输入“java –jar StudyJava.jar”命令运行JAR文件。如下图所示。其中“java”是运行Java程序的命令，“-jar”是运行参数，意思是要运行JAR文件，而后面跟随的就是JAR文件的全程（包括扩展名称）。

C. Linux下如何打包java文件（jar文件），打包成安装文件

tar 没有这种功能。

D. java如何打包

建议使用ANT打包工具，下载地址:http://apache.justdn.org/ant/binaries/apache-ant-1.6.5-bin.zip

此工具用java编写，跨平台，能实现很多功能：编译、打包、运行、文件操作、数据库操作、自定义任务等。

主要使用方法：在工程目录下编写build.xml配置文件，然后运行ant即可：
#ant
或
#java -jar ant.jar
下面给你提供一个例子，是jakarta-oro-2.0.8的包的build.xml
<?xml version="1.0"?>
<project default="jar">



<property file="build.properties"/>



<target name="splash">
<splash imageurl="./ant_logo_medium.gif"/>
</target>

<target name="prepare" depends="splash" description="Creates build directories.">
<tstamp>
<format property="DATE" pattern="yyyy-MM-dd hh:mm:ss" />
</tstamp>
<mkdir dir="${build.dest}"/>
<mkdir dir="${build.dest}/META-INF"/>
< todir="${build.dest}/META-INF">
<fileset dir="${top.dir}">
<include name="LICENSE"/>
</fileset>
</>
<mkdir dir="${build.tests}"/>
<available file="${jakarta-site2.dir}/lib" type="dir"
property="AnakiaTask.present"/>
</target>

<target name="prepare-error" depends="prepare"
description="Prints error message for prepare target."
unless="AnakiaTask.present">
<echo>
AnakiaTask is not present! Please check to make sure that
velocity.jar is in your classpath.
</echo>
</target>



<target name="lib" depends="prepare"
description="Compiles the library classes only.">
<javac srcdir="${build.src}"
destdir="${build.dest}"
excludes="examples/**,tools/**"
debug="${debug}"
deprecation="${deprecation}"
optimize="${optimize}"/>
</target>



<target name="examples" depends="prepare,lib"
description="Compiles the example classes.">
<javac srcdir="${build.src}"
destdir="${build.dest}"
includes="examples/**"
debug="${debug}"
deprecation="${deprecation}"
optimize="${optimize}"/>
</target>



<target name="tools" depends="prepare,lib"
description="Compiles the tool classes.">
<javac srcdir="${build.src}"
destdir="${build.dest}"
includes="tools/**"
debug="${debug}"
deprecation="${deprecation}"
optimize="${optimize}"/>
</target>



<target name="tests" depends="prepare,lib"
description="Compiles and runs the unit tests.">
<javac srcdir="${build.src}/tests"
destdir="${build.tests}"
debug="${debug}"
deprecation="${deprecation}"
optimize="${optimize}"/>
</target>



<target name="jar" depends="lib" description="Compiles the source directory and creates a .jar file.">
<jar jarfile="${top.dir}/${final.name}.jar"
basedir="${build.dest}"
includes="org/**,META-INF/**"
excludes="**/package.html,**/overview.html">
<manifest>
<section name="org/apache/oro">
<attribute name="Specification-Title"
value="Jakarta ORO" />
<attribute name="Specification-Version"
value="${version}" />
<attribute name="Specification-Vendor"
value="Apache Software Foundation" />
<attribute name="Implementation-Title"
value="org.apache.oro" />
<attribute name="Implementation-Version"
value="${version} ${DATE}" />
<attribute name="Implementation-Vendor"
value="Apache Software Foundation" />
</section>
</manifest>
</jar>
</target>



<target name="javadocs" depends="prepare"
description="Creates the API documentation.">
<mkdir dir="${javadoc.destdir}"/>
<javadoc packagenames="org.apache.oro.io,org.apache.oro.text,org.apache.oro.text.regex,org.apache.oro.text.awk,org.apache.oro.text.perl,org.apache.oro.util"
sourcepath="${build.src}"
destdir="${javadoc.destdir}"
overview="${build.src}/org/apache/oro/overview.html"
author="true"
version="true"
windowtitle="${name} ${version} API"
doctitle="${name} ${version} API"
header="<a href='http://jakarta.apache.org/oro/' target=_top><img src='{@docroot}/../images/logoSmall.gif' alt='Jakarta ORO' width=48 height=47 align=center border=0 hspace=1 vspace=1></a>"
bottom="Copyright © ${year} Apache Software Foundation. All Rights Reserved.">
</javadoc>
<replace file="${javadoc.destdir}/overview-frame.html"
token="{@docroot}" value="."/>
<replace dir="${javadoc.destdir}" includes="**/*.html"
token="@version@" value="${version}"/>
</target>


<target name="docs" depends="prepare-error,lib,examples"
description="Creates the project web pages and documentation."
if="AnakiaTask.present">
<taskdef name="anakia" classname="org.apache.velocity.anakia.AnakiaTask">
<classpath>
<fileset dir="${jakarta-site2.dir}/lib">
<include name="*.jar"/>
</fileset>
</classpath>
</taskdef>

<anakia basedir="${docs.src}" destdir="${docs.dest}/"
extension=".html" style="./site.vsl"
projectFile="stylesheets/project.xml"
excludes="**/stylesheets/** manual/** empty.xml"
includes="**/*.xml"
lastModifiedCheck="true"
templatePath="${jakarta-site2.dir}/xdocs/stylesheets">
</anakia>

< todir="${docs.dest}/images" filtering="no">
<fileset dir="${docs.src}/images">
<include name="**/*.gif"/>
<include name="**/*.jpeg"/>
<include name="**/*.jpg"/>
</fileset>
</>

<mkdir dir="${docs.dest}/classes"/>
<mkdir dir="${docs.dest}/classes/examples"/>
< todir="${docs.dest}/classes/examples" filtering="no">
<fileset dir="${build.dest}/examples">
<include name="MatcherDemoApplet.class"/>
</fileset>
</>
<mkdir dir="${docs.dest}/classes/org"/>
< todir="${docs.dest}/classes/org" filtering="no">
<fileset dir="${build.dest}/org">
<include name="**/*.class"/>
</fileset>
</>
</target>



<target name="package" depends="jar,javadocs,docs"
description="Creates a distribution directory tree.">
<mkdir dir="${final.dir}"/>
< todir="${final.dir}/src">
<fileset dir="${code.src}"/>
</>


< todir="${final.dir}/docs">
<fileset dir="${docs.dest}">
<exclude name="manual/**"/>
</fileset>
</>


< file="${top.dir}/build.xml" tofile="${final.dir}/build.xml"/>
< file="${top.dir}/build.properties"
tofile="${final.dir}/build.properties"/>

< file="${top.dir}/LICENSE" tofile="${final.dir}/LICENSE"/>
< file="${top.dir}/ISSUES" tofile="${final.dir}/ISSUES"/>
< file="${top.dir}/CHANGES" tofile="${final.dir}/CHANGES"/>
< file="${top.dir}/COMPILE" tofile="${final.dir}/COMPILE"/>
< file="${top.dir}/CONTRIBUTORS"
tofile="${final.dir}/CONTRIBUTORS"/>
< file="${top.dir}/README" tofile="${final.dir}/README"/>
< file="${top.dir}/STYLE" tofile="${final.dir}/STYLE"/>
< file="${top.dir}/TODO" tofile="${final.dir}/TODO"/>
< file="${top.dir}/${final.name}.jar" tofile="${final.dir}/${final.name}.jar"/>
</target>



<target name="package-zip" depends="package"
description="Packages the distribution as a zip file.">
<zip zipfile="${top.dir}/${final.name}.zip" basedir="${top.dir}/"
includes="**/${final.name}/**" excludes="**/.cvsignore"/>
</target>



<target name="package-tgz" depends="package"
description="Packages the distribution as a gzipped tar file.">
<tar tarfile="${top.dir}/${final.name}.tar"
basedir="${top.dir}" excludes="**/**">
<tarfileset dir="${final.dir}/..">
<include name="${final.name}/**"/>
<exclude name="**/.cvsignore"/>
</tarfileset>
</tar>
<gzip zipfile="${top.dir}/${project}-${version}.tar.gz" src="${top.dir}/${project}-${version}.tar"/>
</target>



<target name="package-all" depends="package-zip, package-tgz">
</target>



<target name="clean"
description="Removes generated artifacts from source tree.">
<delete dir="${build.dest}"/>
<delete dir="${javadoc.destdir}"/>
<delete dir="${final.dir}"/>
<delete file="${top.dir}/${final.name}.jar"/>
<delete file="${top.dir}/${final.name}.tar"/>
<delete file="${top.dir}/${final.name}.tar.gz"/>
<delete file="${top.dir}/${final.name}.zip"/>
<delete>
<fileset dir="${top.dir}" includes="velocity.log*"/>
</delete>

</target>
</project>

build.xml文件的编写可参见ant发行版中的使用文档

你也可以自己编写脚本打包，使用jdk发行版中的jar命令，例如：
#jar cmf myManifestFile myFile.jar *.class
注意还需要自己编写MANIFEST.MF文件配置包属性。具体可以参见javadoc

当然还可以使用集成开发环境提供的打包工具，如JBuilder提供打包工具，但这样程序的移植性不强，建议不要使用，就使用ant比较好。

E. 我想把java文件先加密然后打包，请高手指教怎么加密，有那种好的加密算法吗

RSA算法非常简单，概述如下：
找两素数p和q
取n=p*q
取t=(p-1)*(q-1)
取任何一个数e,要求满足e<t并且e与t互素（就是最大公因数为1）
取d*e%t==1

这样最终得到三个数： n d e

设消息为数M (M <n)
设c=(M**d)%n就得到了加密后的消息c
设m=(c**e)%n则 m == M，从而完成对c的解密。
注：**表示次方,上面两式中的d和e可以互换。

在对称加密中：
n d两个数构成公钥，可以告诉别人；
n e两个数构成私钥，e自己保留，不让任何人知道。
给别人发送的信息使用e加密，只要别人能用d解开就证明信息是由你发送的，构成了签名机制。
别人给你发送信息时使用d加密，这样只有拥有e的你能够对其解密。

rsa的安全性在于对于一个大数n，没有有效的方法能够将其分解
从而在已知n d的情况下无法获得e；同样在已知n e的情况下无法
求得d。

<二>实践

接下来我们来一个实践，看看实际的操作：
找两个素数：
p=47
q=59
这样
n=p*q=2773
t=(p-1)*(q-1)=2668
取e=63，满足e<t并且e和t互素
用perl简单穷举可以获得满主 e*d%t ==1的数d：
C:\Temp>perl -e "foreach $i (1..9999){ print($i),last if $i*63%2668==1 }"
847
即d＝847

最终我们获得关键的
n=2773
d=847
e=63

取消息M=244我们看看

加密：

c=M**d%n = 244**847%2773
用perl的大数计算来算一下：
C:\Temp>perl -Mbigint -e "print 244**847%2773"
465
即用d对M加密后获得加密信息c＝465

解密：

我们可以用e来对加密后的c进行解密，还原M：
m=c**e%n=465**63%2773 ：
C:\Temp>perl -Mbigint -e "print 465**63%2773"
244
即用e对c解密后获得m=244 , 该值和原始信息M相等。

<三>字符串加密

把上面的过程集成一下我们就能实现一个对字符串加密解密的示例了。
每次取字符串中的一个字符的ascii值作为M进行计算，其输出为加密后16进制
的数的字符串形式，按3字节表示，如01F

代码如下：

#!/usr/bin/perl -w
#RSA 计算过程学习程序编写的测试程序
#watercloud 2003-8-12
#
use strict;
use Math::BigInt;

my %RSA_CORE = (n=>2773,e=>63,d=>847); #p=47,q=59

my $N=new Math::BigInt($RSA_CORE{n});
my $E=new Math::BigInt($RSA_CORE{e});
my $D=new Math::BigInt($RSA_CORE{d});

print "N=$N D=$D E=$E\n";

sub RSA_ENCRYPT
{
my $r_mess = shift @_;
my ($c,$i,$M,$C,$cmess);

for($i=0;$i < length($$r_mess);$i++)
{
$c=ord(substr($$r_mess,$i,1));
$M=Math::BigInt->new($c);
$C=$M->(); $C->bmodpow($D,$N);
$c=sprintf "%03X",$C;
$cmess.=$c;
}
return \$cmess;
}

sub RSA_DECRYPT
{
my $r_mess = shift @_;
my ($c,$i,$M,$C,$dmess);

for($i=0;$i < length($$r_mess);$i+=3)
{
$c=substr($$r_mess,$i,3);
$c=hex($c);
$M=Math::BigInt->new($c);
$C=$M->(); $C->bmodpow($E,$N);
$c=chr($C);
$dmess.=$c;
}
return \$dmess;
}

my $mess="RSA 娃哈哈哈～～～";
$mess=$ARGV[0] if @ARGV >= 1;
print "原始串：",$mess,"\n";

my $r_cmess = RSA_ENCRYPT(\$mess);
print "加密串：",$$r_cmess,"\n";

my $r_dmess = RSA_DECRYPT($r_cmess);
print "解密串：",$$r_dmess,"\n";

#EOF

测试一下：
C:\Temp>perl rsa-test.pl
N=2773 D=847 E=63
原始串：RSA 娃哈哈哈～～～
加密串：
解密串：RSA 娃哈哈哈～～～

C:\Temp>perl rsa-test.pl 安全焦点（xfocus）
N=2773 D=847 E=63
原始串：安全焦点（xfocus）
加密串：
解密串：安全焦点（xfocus）

<四>提高

前面已经提到，rsa的安全来源于n足够大，我们测试中使用的n是非常小的，根本不能保障安全性，
我们可以通过RSAKit、RSATool之类的工具获得足够大的N 及D E。
通过工具，我们获得1024位的N及D E来测试一下：

n=EC3A85F5005D
4C2013433B383B
A50E114705D7E2
BC511951

d=0x10001

e=DD28C523C2995
47B77324E66AFF2
789BD782A592D2B
1965

设原始信息
M=

完成这么大数字的计算依赖于大数运算库，用perl来运算非常简单：

A) 用d对M进行加密如下：
c=M**d%n :
C:\Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x11111111111122222222222233
333333333, 0x10001,
D55EDBC4F0
6E37108DD6
);print $x->as_hex"
b73d2576bd
47715caa6b
d59ea89b91
f1834580c3f6d90898

即用d对M加密后信息为：
c=b73d2576bd
47715caa6b
d59ea89b91
f1834580c3f6d90898

B) 用e对c进行解密如下：

m=c**e%n ：
C:\Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x17b287be418c69ecd7c39227ab
5aa1d99ef3
0cb4764414
, 0xE760A
3C29954C5D
7324E66AFF
2789BD782A
592D2B1965, CD15F90
4F017F9CCF
DD60438941
);print $x->as_hex"

(我的P4 1.6G的机器上计算了约5秒钟）

得到用e解密后的m= == M

C) RSA通常的实现
RSA简洁幽雅，但计算速度比较慢，通常加密中并不是直接使用RSA 来对所有的信息进行加密，
最常见的情况是随机产生一个对称加密的密钥，然后使用对称加密算法对信息加密，之后用
RSA对刚才的加密密钥进行加密。

最后需要说明的是，当前小于1024位的N已经被证明是不安全的
自己使用中不要使用小于1024位的RSA，最好使用2048位的。

----------------------------------------------------------

一个简单的RSA算法实现JAVA源代码：

filename:RSA.java

/*
* Created on Mar 3, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/

import java.math.BigInteger;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferedReader;
import java.util.StringTokenizer;

/**
* @author Steve
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class RSA {

/**
* BigInteger.ZERO
*/
private static final BigInteger ZERO = BigInteger.ZERO;

/**
* BigInteger.ONE
*/
private static final BigInteger ONE = BigInteger.ONE;

/**
* Pseudo BigInteger.TWO
*/
private static final BigInteger TWO = new BigInteger("2");

private BigInteger myKey;

private BigInteger myMod;

private int blockSize;

public RSA (BigInteger key, BigInteger n, int b) {
myKey = key;
myMod = n;
blockSize = b;
}

public void encodeFile (String filename) {
byte[] bytes = new byte[blockSize / 8 + 1];
byte[] temp;
int tempLen;
InputStream is = null;
FileWriter writer = null;
try {
is = new FileInputStream(filename);
writer = new FileWriter(filename + ".enc");
}
catch (FileNotFoundException e1){
System.out.println("File not found: " + filename);
}
catch (IOException e1){
System.out.println("File not found: " + filename + ".enc");
}

/**
* Write encoded message to 'filename'.enc
*/
try {
while ((tempLen = is.read(bytes, 1, blockSize / 8)) > 0) {
for (int i = tempLen + 1; i < bytes.length; ++i) {
bytes[i] = 0;
}
writer.write(encodeDecode(new BigInteger(bytes)) + " ");
}
}
catch (IOException e1) {
System.out.println("error writing to file");
}

/**
* Close input stream and file writer
*/
try {
is.close();
writer.close();
}
catch (IOException e1) {
System.out.println("Error closing file.");
}
}

public void decodeFile (String filename) {

FileReader reader = null;
OutputStream os = null;
try {
reader = new FileReader(filename);
os = new FileOutputStream(filename.replaceAll(".enc", ".dec"));
}
catch (FileNotFoundException e1) {
if (reader == null)
System.out.println("File not found: " + filename);
else
System.out.println("File not found: " + filename.replaceAll(".enc", "dec"));
}

BufferedReader br = new BufferedReader(reader);
int offset;
byte[] temp, toFile;
StringTokenizer st = null;
try {
while (br.ready()) {
st = new StringTokenizer(br.readLine());
while (st.hasMoreTokens()){
toFile = encodeDecode(new BigInteger(st.nextToken())).toByteArray();
System.out.println(toFile.length + " x " + (blockSize / 8));

if (toFile[0] == 0 && toFile.length != (blockSize / 8)) {
temp = new byte[blockSize / 8];
offset = temp.length - toFile.length;
for (int i = toFile.length - 1; (i <= 0) && ((i + offset) <= 0); --i) {
temp[i + offset] = toFile[i];
}
toFile = temp;
}

/*if (toFile.length != ((blockSize / 8) + 1)){
temp = new byte[(blockSize / 8) + 1];
System.out.println(toFile.length + " x " + temp.length);
for (int i = 1; i < temp.length; i++) {
temp[i] = toFile[i - 1];
}
toFile = temp;
}
else
System.out.println(toFile.length + " " + ((blockSize / 8) + 1));*/
os.write(toFile);
}
}
}
catch (IOException e1) {
System.out.println("Something went wrong");
}

/**
* close data streams
*/
try {
os.close();
reader.close();
}
catch (IOException e1) {
System.out.println("Error closing file.");
}
}

/**
* Performs <tt>base</tt>^<sup><tt>pow</tt></sup> within the molar
* domain of <tt>mod</tt>.
*
* @param base the base to be raised
* @param pow the power to which the base will be raisded
* @param mod the molar domain over which to perform this operation
* @return <tt>base</tt>^<sup><tt>pow</tt></sup> within the molar
* domain of <tt>mod</tt>.
*/
public BigInteger encodeDecode(BigInteger base) {
BigInteger a = ONE;
BigInteger s = base;
BigInteger n = myKey;

while (!n.equals(ZERO)) {
if(!n.mod(TWO).equals(ZERO))
a = a.multiply(s).mod(myMod);

s = s.pow(2).mod(myMod);
n = n.divide(TWO);
}

return a;
}

}

在这里提供两个版本的RSA算法JAVA实现的代码下载：

1. 来自于 http://www.javafr.com/code.aspx?ID=27020 的RSA算法实现源代码包:
http://zeal.newmenbase.net/attachment/JavaFR_RSA_Source.rar

2. 来自于 http://www.ferrara.linux.it/Members/lucabariani/RSA/implementazioneRsa/ 的实现:
http://zeal.newmenbase.net/attachment/sorgentiJava.tar.gz - 源代码包
http://zeal.newmenbase.net/attachment/algoritmoRSA.jar - 编译好的jar包

另外关于RSA算法的php实现请参见文章:
php下的RSA算法实现

关于使用VB实现RSA算法的源代码下载(此程序采用了psc1算法来实现快速的RSA加密):
http://zeal.newmenbase.net/attachment/vb_PSC1_RSA.rar

RSA加密的JavaScript实现: http://www.ohdave.com/rsa/
参考资料：http://www.lenovonet.com/proct/showarticle.asp?id=118

F. tar包和jar包和war包的区别

tar是通用的另一种打包格式，为了部署到服务器时方便。而jar是java app server识别的java部署格式，其实是Zip文件，只是内部的文件有规范。
war是专用于web app的jar。另外还有用于enterprise app的ear后缀。
相同点是都可以把多个文件打包到一个文件，不同点是 jar是个压缩文件，而tar只打包，不压缩，所以tar还要配合其他压缩工具来压缩，比如tar.bz2,tar.gz 之类的就是在tar的基础上进行的压缩格式。

G. 压缩文件的格式有哪几种，一般手机支持哪几种呢

压缩文件有很多种，常见的有rar 、zip 。

普通手机不支持压缩文件。好多智能手机上有zip管理器，同时支持rar 和zip 。注意jar 的文件虽然是压缩包，但它是java 应用程序的一种格式，与实际意义上的压缩文件不一样。

文件被压缩以后，文件格式一般有. rar和. zip两种格式。想要压缩电脑文件时，前提需要电脑中安装了压缩应用，比如说快压、360压缩等。电脑安装了压缩应用以后，右键单击一个文件夹，然后在弹出的菜单栏中点击“添加到压缩文件(A)”选项，接着会弹出一个压缩窗口。

(7)javatar打包扩展阅读：

压缩格式的优缺点：

zip也有很多缺点，比如zip打包的时候没有记录文件信息是什么格式，最常见的问题就是文件名为GBK编码的Windows操作系统制作的zip压缩包在*nix系统(文件名为UTF-8编码)下显示为乱码。

而且我看还有答主说文件时间也只是记录了一个时间值，并没有说明这是什么格式的时间，也就是说zip是一个相当简单的，没有考虑太多交叉环境情况下使用的压缩格式。

tar并不是压缩格式，tar只是一个打包工具，tar经常在*nix系统下出现，不过由于Linux的tar命令可以自动启动后续的压缩程序打包后一并压缩，以及tar在windows系统下一般被压缩软件支持打开，所以被误认为是压缩格式。

由于这个细微的差别，在Linux下常见的文件名后缀 "*.tar.gz"代表着这个归档先以tar打包，然后以gnuzip压缩，"*.tar.bz2"代表着这个归档先以tar打包后以bzip2压缩，类似文件名后缀都表达了类似含义。

H. 如何使用myeclipse工具导出.tar的java包

利用Eclipse的一个第三方插件fatjar生成jar文件，也是本人觉得最简单最方便的一种生成方式。先从网上下载些插件，解压后是一个plugins的文件夹，里面只有一个文件夹，我的“net.sf.fjep.fatjar_0.0.24”将它到Eclipser plugins文件夹下，此插件就安装成功了，重启Eclipse在项目上右击就会看到多出一个“Build Fat Jar”在前面有个绿色的“+”号，这时你就可以用此插件打包你的项目了。进去后第一个界面Jar-Name里增入要生成的jar文件名，我的是“CAMP_fat.jar”。在Main-Class后点Browse像Export一样它也会列出你项目中的主类，选择后其它默认即可，Next后会列出你要打包的所有内容，这个插件的优势就是可以将你项目中的外部jar也打进来，有三个先项，其中Export ANT是生成build.xml脚本文件，方便用户以后修改脚本，其它两个按钮没用。在这里什么都不点，直接点Finish就可以生成jar文件。
2.将jar打成.exe文件：
2.1 虽然此时的jar文件已经可以执行了。生成.exe的文件我也是用两种方法实现的，用到的打包工具是j2ewiz和exe4j，它们的不同会在我下面的介绍中体现出来。
2.2 首先是j2ewiz，这个软件是绿色的，不用安装，解压后可以直接运行，但这个软件生成的 .exe文件不是跨平台的。运行此程序首先就是输入要打包的jar文件，我们浏览JAR选择我们之前用fatjar生成的“CAMP_fat.jar”项目文件（详见1.3），下面那个选项是提示用户最低要求的JRE版本，一般选1.3。下一步，因为我们的寝室管理系统是图形界面，所以在这里选“Windows窗口程序”下一步它也是自动生成要执行的主类，你只要选择就可以。下面的选框可以选择你启动程序显示的图片。下一步后这个窗可按个人喜好选择。下一步，如果你的程序还有什么依赖的外部jar文件，可以从这里加上，但因为之前的fatjar以经将我们项目所用的那三个连数据库的外部类打进CAMP_fat.jar包里了，所以这里不用再添加。如果你之前是用Export打的jar包，那么这里就需要再把那个三个数据库的包加进来了（详见1.2）。下一步是添入要生成的.exe文件名，再选一个程序图标就可以了，下一步后生成.exe文件，点完成。双击生成的.exe文件就能看到运行效果了，这种exe文件还没有脱离JDK环境，还不能跨平台使用，只能用于小组成员测试使用。
2.3 ＝下面进入最关键的，如何打包跨平台的.exe文件。用到的软件是exe4j,我用的是V4.0版的，此软件需要破解。安装后运行左窗窗口标有十步，其实打包过程也非常简单。第一步完全略过，直接点Next第二步我们选择“JAR
in EXE mode” 就是选择我们已经有制作好的jar文件。第3步上面是项目名称，可随便填写，下面一个写出你想要将打包后的exe文件输出的目录我的是“桌面\project\”。第4步，由于我的演示程序是图形的，所以选第一个，如果你的程序是控制台的，则选择第二个，Executable name写你将要生成的.exe文件的名字，Icon File可以选择生成文件的图标。第5步，先别管上面的，先在下面单击绿色的“+”号，在弹出的窗口中点Archive，然后找到起初已经做好的CAMP_fat.jar（详见1.3）文件，"OK"后返回，在下面的Class Path里就出现jar文件路径后，再在上面Main Class栏内点击找到main所在的类。第6步，你系统的JRE版本，一般是填个1.3，下面填1.6在这里单击advanced options，选择search sequence。选这个就是因为我们要把JDK环境也打包进来，好让程序能跨平台使用。首先要从你系统的JDK下的JRE目录到你.exe文件的输出目录下“桌面\project\JRE”，然后回到exe4j中在弹出窗口删除列表中的所有项。我的是三项，一个注册表的，一个JAVA环境变量的，一个JDK环境变量的，都不要。然后单击绿“+”，选择directory并选择JRE的根目录，我的是“桌面\project\JRE”就是后的目录，选完后exe4j弹出窗口中的Directory里会显示“.\JRE”。点OK关闭该窗口，返回exe4j的主窗口，你就可以看到刚加的路径。再从主窗口左侧窗口中单击advanced options，并选择preferred VM，在弹出的窗口中选择client hostspot VM，单击next按钮继续。7、8步是一些个性设置默认即可。第9步编译完后第10步你点那个“Click Here to Start the Application”按钮就可以看到程序运行效果了，然后再点”Seave as”保存一个exe4j生成的一个文件，随便存哪里都行，和我们的.exe程序无关。全部制作过程就完工了。

I. java程序从D盘读取.TXT文档数据。按要求改变数据格式，然后打包成.TAR后缀名。保存到服务器的共享盘E

importjava.io.BufferedReader;

importjava.io.BufferedWriter;

importjava.io.File;

importjava.io.FileNotFoundException;

importjava.io.FileReader;

importjava.io.FileWriter;

importjava.io.IOException;

publicclassTxtReader{

publicstaticvoidmain(String[]args){

StringinputTxtPath="d:/test.txt";//需要读取的TXT的路径

StringoutputTarPath="e:/test.tar";//需要写到哪的路径文件可以不存在，代码创建

String[]line=readTxt(inputTxtPath);//只需要动态改变上面两个地址即可

if(line!=null){

booleansign=writeTar(outputTarPath,line);

if(sign){

System.out.println("写入成功...");

}else{

System.out.println("写入失败...");

}

/**

*读取TXT方法

*@paramtxtPath

*文件的路径

*@return返回一个拆分好的数组

publicstaticString[]readTxt(StringtxtPath){

String[]line=null;

try{

FileReaderreader=newFileReader(newFile(txtPath));

BufferedReaderbuffReader=newBufferedReader(reader);

Stringcontent=buffReader.readLine();

line=content.split("");

buffReader.close();

reader.close();

}catch(FileNotFoundExceptione){

System.out.println("txt文件不存在，无法读取...");

}catch(IOExceptione){

e.printStackTrace();

}

returnline;

}

/**

*写入Tar方法

*@paramtarPath

*写到什么地方(如果空则创建)

*@paramline

*读取TXT方法获得了数组

*@return返回true或false

publicstaticbooleanwriteTar(StringtarPath,String[]line){

booleansign=false;

if(line!=null){

try{

FileWriterwriter=newFileWriter(newFile(tarPath));

BufferedWriterbuffWriter=newBufferedWriter(writer);

for(inti=0;i<line.length;i++){

if(!line[i].equals(""))

buffWriter.write(line[i]+" ");

}

buffWriter.flush();

buffWriter.close();

writer.close();

sign=true;

}catch(IOExceptione){

e.printStackTrace();

}

returnsign;

}

最后：

希望能帮到你，以后提JAVA的问题请到JAVA分类。

有什么问题Hi我，我的Hi在线。

J. 如何使用java snappy压缩文件

使用下面命令
tar -zcvf target.tgz source/
tar -jcvf target.tar.bz2 source/
tar打包，gzip压缩,bzip2压缩
man tar，man gzip，man bzip 具有例子及解释，关于linux命令的使用情况，我最近在看一本书籍，不过是电子版的《linux就该这么学》，明年3月份即将出版，你到时可以购买一本好好看看，关于命令的参数讲解得非常的详细。

导航:首页 > 编程语言 > javatar打包

javatar打包

(7)javatar打包扩展阅读：

与javatar打包相关的资料