下面列出了java.util.zip.ZipEntry#setTime ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public byte[] toByteArray() {
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ZipOutputStream zipper = new ZipOutputStream(out);
for (Entry entry : entries) {
ZipEntry zipEntry = new ZipEntry(entry.name);
if (entry.compressed) {
zipEntry.setMethod(ZipEntry.DEFLATED);
} else {
zipEntry.setMethod(ZipEntry.STORED);
zipEntry.setSize(entry.content.length);
zipEntry.setCrc(calculateCrc32(entry.content));
}
zipEntry.setTime(ZipCombiner.DOS_EPOCH.getTime());
zipper.putNextEntry(zipEntry);
zipper.write(entry.content);
zipper.closeEntry();
}
zipper.close();
return out.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* 压缩文件
*
*/
private static void compressFile(File file, ZipOutputStream zos, String baseDir) {
if (!file.exists()) {
return;
}
try {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
ZipEntry entry = new ZipEntry(baseDir + file.getName());
entry.setTime(file.lastModified());
zos.putNextEntry(entry);
int count;
byte[] buf = new byte[8192];
while ((count = bis.read(buf)) != -1) {
zos.write(buf, 0, count);
}
bis.close();
} catch (Exception e) {
LOGGER.error("", e);
}
}
@Test
public void shouldBeAbleToAddASingleNonZeroLengthFile() throws IOException {
File reference = File.createTempFile("reference", ".zip");
try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output, mode);
ZipOutputStream ref = new ZipOutputStream(new FileOutputStream(reference))) {
byte[] bytes = "cheese".getBytes();
ZipEntry entry = new ZipEntry("example.txt");
entry.setTime(System.currentTimeMillis());
out.putNextEntry(entry);
ref.putNextEntry(entry);
out.write(bytes);
ref.write(bytes);
}
byte[] seen = Files.readAllBytes(output);
byte[] expected = Files.readAllBytes(reference.toPath());
assertArrayEquals(expected, seen);
}
static void testTimeConversions(long from, long to, long step) {
ZipEntry ze = new ZipEntry("TestExtraTime.java");
for (long time = from; time <= to; time += step) {
ze.setTime(time);
FileTime lastModifiedTime = ze.getLastModifiedTime();
if (lastModifiedTime.toMillis() != time) {
throw new RuntimeException("setTime should make getLastModifiedTime " +
"return the specified instant: " + time +
" got: " + lastModifiedTime.toMillis());
}
if (ze.getTime() != time) {
throw new RuntimeException("getTime after setTime, expected: " +
time + " got: " + ze.getTime());
}
}
}
@Test public void testZipEntryInvalidTime() throws IOException {
long date = 312796800000L; // 11/30/1979 00:00:00, which is also 0 in DOS format
byte[] extra = new ExtraData((short) 0xaa, new byte[] { (byte) 0xbb, (byte) 0xcd }).getBytes();
try (ZipOutputStream zout = new ZipOutputStream(new FileOutputStream(test))) {
ZipEntry foo = new ZipEntry("foo");
foo.setComment("foo comment.");
foo.setMethod(ZipEntry.DEFLATED);
foo.setTime(date);
foo.setExtra(extra);
zout.putNextEntry(foo);
zout.write("foo".getBytes(UTF_8));
zout.closeEntry();
}
try (ZipReader reader = new ZipReader(test, UTF_8)) {
ZipFileEntry fooEntry = reader.getEntry("foo");
assertThat(fooEntry.getTime()).isEqualTo(ZipUtil.DOS_EPOCH);
}
}
private void checkSetTime(long time) throws IOException {
File f = createTemporaryZipFile();
ZipOutputStream out = createZipOutputStream(f);
ZipEntry ze = new ZipEntry("x");
ze.setSize(0);
ze.setTime(time);
out.putNextEntry(ze);
out.closeEntry();
out.close();
// Read it back, and check that we see the entry.
ZipFile zipFile = new ZipFile(f);
assertEquals(time, zipFile.getEntry("x").getTime());
zipFile.close();
}
static void addFile(
ZipOutputStream zos,
File f, String dbName, int old) throws IOException
{
String s = f.getPath().replace(File.separatorChar, '/');
s = s.substring(old);
s = dbName.concat(s);
// jar has forward slashes!
ZipEntry ze= new ZipEntry(s);
ze.setTime(f.lastModified());
zos.putNextEntry(ze);
byte[] byte8= new byte[1024];
BufferedInputStream bufferedInputStream10= new BufferedInputStream((new FileInputStream(f)));
while (true)
{
int int9= bufferedInputStream10.read(byte8, 0, byte8.length);
if (int9 == -1)
{
break;
}
zos.write(byte8, 0, int9);
}
bufferedInputStream10.close();
zos.closeEntry();
}
/**
* Test standard and info-zip-extended timestamp rounding
*/
public void test_timeSerializationRounding() throws Exception {
List<ZipEntry> entries = new ArrayList<>();
ZipEntry zipEntry;
entries.add(zipEntry = new ZipEntry("test1"));
final long someTimestamp = 1479139143200L;
zipEntry.setTime(someTimestamp);
entries.add(zipEntry = new ZipEntry("test2"));
zipEntry.setLastModifiedTime(FileTime.fromMillis(someTimestamp));
for (ZipEntry entry : entries) {
zos.putNextEntry(entry);
zos.write(data.getBytes());
zos.closeEntry();
}
zos.close();
try (ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(bos.toByteArray()))) {
// getTime should be rounded down to a multiple of 2s
ZipEntry readEntry = zis.getNextEntry();
assertEquals((someTimestamp / 2000) * 2000,
readEntry.getTime());
// With extended timestamp getTime&getLastModifiedTime should berounded down to a
// multiple of 1s
readEntry = zis.getNextEntry();
assertEquals((someTimestamp / 1000) * 1000,
readEntry.getLastModifiedTime().toMillis());
assertEquals((someTimestamp / 1000) * 1000,
readEntry.getTime());
}
}
/**
* Private helper function for zipping files. This one goes recursively through the input
* directory and all of its subdirectories and adds the single zip entries.
*
* @param inputFile the file or directory to be added to the zip file
* @param directoryName the string-representation of the parent directory name. Might be an empty
* name, or a name containing multiple directory names separated by "/". The directory name
* must be a valid name according to the file system limitations. The directory name should be
* empty or should end in "/".
* @param zos the zipstream to write to
* @throws IOException the zipping failed, e.g. because the output was not writeable.
*/
private static void zipDirectoryInternal(
File inputFile, String directoryName, ZipOutputStream zos) throws IOException {
String entryName = directoryName + inputFile.getName();
if (inputFile.isDirectory()) {
entryName += "/";
// We are hitting a sub-directory. Recursively add children to zip in deterministic,
// sorted order.
File[] childFiles = inputFile.listFiles();
if (childFiles.length > 0) {
Arrays.sort(childFiles);
// loop through the directory content, and zip the files
for (File file : childFiles) {
zipDirectoryInternal(file, entryName, zos);
}
// Since this directory has children, exit now without creating a zipentry specific to
// this directory. The entry for a non-entry directory is incompatible with certain
// implementations of unzip.
return;
}
}
// Put the zip-entry for this file or empty directory into the zipoutputstream.
ZipEntry entry = new ZipEntry(entryName);
entry.setTime(inputFile.lastModified());
zos.putNextEntry(entry);
// Copy file contents into zipoutput stream.
if (inputFile.isFile()) {
Files.asByteSource(inputFile).copyTo(zos);
}
}
public ZipEntry newZipEntry(ZipEntry ze) {
ZipEntry ze2 = new ZipEntry(ze.getName());
ze2.setComment(ze.getComment());
ze2.setTime(ze.getTime());
ze2.setExtra(ze.getExtra());
return ze2;
}
private static void addFile(ZipOutputStream zos, File f, String dbName, int old)
throws IOException {
String s = f.getPath().replace(File.separatorChar, '/');
s = s.substring(old);
s = dbName.concat(s);
// jar has forward slashes!
ZipEntry ze = new ZipEntry(s);
ze.setTime(f.lastModified());
zos.putNextEntry(ze);
byte[] buf = new byte[4096];
BufferedInputStream in = new BufferedInputStream(
(new FileInputStream(f)));
while (true) {
int read = in.read(buf);
if (read == -1) {
break;
}
zos.write(buf, 0, read);
}
in.close();
zos.closeEntry();
}
/**
* Compress a file or recursively compress all files of a folder.
*
* @param sourceFile
* @param destinationZipFileSream
* @throws IOException
*/
public static void addFileToOpenZipFileStream(final File sourceFile, final String relativeDirPath, final ZipOutputStream destinationZipFileSream) throws IOException {
if (!sourceFile.exists()) {
throw new IOException("SourceFile does not exist");
}
if (destinationZipFileSream == null) {
throw new IOException("DestinationStream is not ready");
}
if (relativeDirPath == null) {
throw new IOException("RelativeDirPath is invalid");
}
try {
if (!sourceFile.isDirectory()) {
final ZipEntry entry = new ZipEntry(relativeDirPath + sourceFile.getName());
entry.setTime(sourceFile.lastModified());
destinationZipFileSream.putNextEntry(entry);
try(final BufferedInputStream bufferedFileInputStream = new BufferedInputStream(new FileInputStream(sourceFile))) {
final byte[] bufferArray = new byte[1024];
int byteBufferFillLength = bufferedFileInputStream.read(bufferArray);
while (byteBufferFillLength > -1) {
destinationZipFileSream.write(bufferArray, 0, byteBufferFillLength);
byteBufferFillLength = bufferedFileInputStream.read(bufferArray);
}
destinationZipFileSream.flush();
destinationZipFileSream.closeEntry();
}
}
else {
for (File sourceSubFile : sourceFile.listFiles()) {
addFileToOpenZipFileStream(sourceSubFile, relativeDirPath + sourceFile.getName() + File.separator, destinationZipFileSream);
}
}
}
catch (IOException e) {
throw e;
}
}
@Test public void testZipEntryFields() throws IOException {
CRC32 crc = new CRC32();
Deflater deflater = new Deflater(Deflater.DEFAULT_COMPRESSION, true);
long date = 791784306000L; // 2/3/1995 04:05:06
byte[] extra = new ExtraData((short) 0xaa, new byte[] { (byte) 0xbb, (byte) 0xcd }).getBytes();
byte[] tmp = new byte[128];
try (ZipOutputStream zout = new ZipOutputStream(new FileOutputStream(test))) {
ZipEntry foo = new ZipEntry("foo");
foo.setComment("foo comment.");
foo.setMethod(ZipEntry.DEFLATED);
foo.setTime(date);
foo.setExtra(extra);
zout.putNextEntry(foo);
zout.write("foo".getBytes(UTF_8));
zout.closeEntry();
ZipEntry bar = new ZipEntry("bar");
bar.setComment("bar comment.");
bar.setMethod(ZipEntry.STORED);
bar.setSize("bar".length());
bar.setCompressedSize("bar".length());
crc.reset();
crc.update("bar".getBytes(UTF_8));
bar.setCrc(crc.getValue());
zout.putNextEntry(bar);
zout.write("bar".getBytes(UTF_8));
zout.closeEntry();
}
try (ZipReader reader = new ZipReader(test, UTF_8)) {
ZipFileEntry fooEntry = reader.getEntry("foo");
assertThat(fooEntry.getName()).isEqualTo("foo");
assertThat(fooEntry.getComment()).isEqualTo("foo comment.");
assertThat(fooEntry.getMethod()).isEqualTo(Compression.DEFLATED);
assertThat(fooEntry.getVersion()).isEqualTo(Compression.DEFLATED.getMinVersion());
assertThat(fooEntry.getTime()).isEqualTo(date);
assertThat(fooEntry.getSize()).isEqualTo("foo".length());
deflater.reset();
deflater.setInput("foo".getBytes(UTF_8));
deflater.finish();
assertThat(fooEntry.getCompressedSize()).isEqualTo(deflater.deflate(tmp));
crc.reset();
crc.update("foo".getBytes(UTF_8));
assertThat(fooEntry.getCrc()).isEqualTo(crc.getValue());
assertThat(fooEntry.getExtra().getBytes()).isEqualTo(extra);
ZipFileEntry barEntry = reader.getEntry("bar");
assertThat(barEntry.getName()).isEqualTo("bar");
assertThat(barEntry.getComment()).isEqualTo("bar comment.");
assertThat(barEntry.getMethod()).isEqualTo(Compression.STORED);
assertThat(barEntry.getVersion()).isEqualTo(Compression.STORED.getMinVersion());
assertDateAboutNow(new Date(barEntry.getTime()));
assertThat(barEntry.getSize()).isEqualTo("bar".length());
assertThat(barEntry.getCompressedSize()).isEqualTo("bar".length());
crc.reset();
crc.update("bar".getBytes(UTF_8));
assertThat(barEntry.getCrc()).isEqualTo(crc.getValue());
assertThat(barEntry.getExtra().getBytes()).isEqualTo(new byte[] {});
}
}
private void writeEntry(JarOutputStream j, String name,
long mtime, long lsize, boolean deflateHint,
ByteBuffer data0, ByteBuffer data1) throws IOException {
int size = (int)lsize;
if (size != lsize)
throw new IOException("file too large: "+lsize);
CRC32 crc32 = _crc32;
if (_verbose > 1)
Utils.log.fine("Writing entry: "+name+" size="+size
+(deflateHint?" deflated":""));
if (_buf.length < size) {
int newSize = size;
while (newSize < _buf.length) {
newSize <<= 1;
if (newSize <= 0) {
newSize = size;
break;
}
}
_buf = new byte[newSize];
}
assert(_buf.length >= size);
int fillp = 0;
if (data0 != null) {
int size0 = data0.capacity();
data0.get(_buf, fillp, size0);
fillp += size0;
}
if (data1 != null) {
int size1 = data1.capacity();
data1.get(_buf, fillp, size1);
fillp += size1;
}
while (fillp < size) {
// Fill in rest of data from the stream itself.
int nr = in.read(_buf, fillp, size - fillp);
if (nr <= 0) throw new IOException("EOF at end of archive");
fillp += nr;
}
ZipEntry z = new ZipEntry(name);
z.setTime(mtime * 1000);
if (size == 0) {
z.setMethod(ZipOutputStream.STORED);
z.setSize(0);
z.setCrc(0);
z.setCompressedSize(0);
} else if (!deflateHint) {
z.setMethod(ZipOutputStream.STORED);
z.setSize(size);
z.setCompressedSize(size);
crc32.reset();
crc32.update(_buf, 0, size);
z.setCrc(crc32.getValue());
} else {
z.setMethod(Deflater.DEFLATED);
z.setSize(size);
}
j.putNextEntry(z);
if (size > 0)
j.write(_buf, 0, size);
j.closeEntry();
if (_verbose > 0) Utils.log.info("Writing " + Utils.zeString(z));
}
public void addFile(String path, File file) throws IOException {
if (!file.isFile()) {
throw new AssertException("Attempted to write a directory to the jar file");
}
long modifiedTime = file.lastModified();
ZipEntry entry = new ZipEntry(path);
entry.setTime(modifiedTime);
zipOut.putNextEntry(entry);
InputStream in = new FileInputStream(file);
byte[] bytes = new byte[4096];
int numRead;
while ((numRead = in.read(bytes)) != -1) {
zipOut.write(bytes, 0, numRead);
}
in.close();
zipOut.closeEntry();
}
private void writeEntry(JarOutputStream j, String name,
long mtime, long lsize, boolean deflateHint,
ByteBuffer data0, ByteBuffer data1) throws IOException {
int size = (int)lsize;
if (size != lsize)
throw new IOException("file too large: "+lsize);
CRC32 crc32 = _crc32;
if (_verbose > 1)
Utils.log.fine("Writing entry: "+name+" size="+size
+(deflateHint?" deflated":""));
if (_buf.length < size) {
int newSize = size;
while (newSize < _buf.length) {
newSize <<= 1;
if (newSize <= 0) {
newSize = size;
break;
}
}
_buf = new byte[newSize];
}
assert(_buf.length >= size);
int fillp = 0;
if (data0 != null) {
int size0 = data0.capacity();
data0.get(_buf, fillp, size0);
fillp += size0;
}
if (data1 != null) {
int size1 = data1.capacity();
data1.get(_buf, fillp, size1);
fillp += size1;
}
while (fillp < size) {
// Fill in rest of data from the stream itself.
int nr = in.read(_buf, fillp, size - fillp);
if (nr <= 0) throw new IOException("EOF at end of archive");
fillp += nr;
}
ZipEntry z = new ZipEntry(name);
z.setTime(mtime * 1000);
if (size == 0) {
z.setMethod(ZipOutputStream.STORED);
z.setSize(0);
z.setCrc(0);
z.setCompressedSize(0);
} else if (!deflateHint) {
z.setMethod(ZipOutputStream.STORED);
z.setSize(size);
z.setCompressedSize(size);
crc32.reset();
crc32.update(_buf, 0, size);
z.setCrc(crc32.getValue());
} else {
z.setMethod(Deflater.DEFLATED);
z.setSize(size);
}
j.putNextEntry(z);
if (size > 0)
j.write(_buf, 0, size);
j.closeEntry();
if (_verbose > 0) Utils.log.info("Writing " + Utils.zeString(z));
}
private void writeEntry(JarOutputStream j, String name,
long mtime, long lsize, boolean deflateHint,
ByteBuffer data0, ByteBuffer data1) throws IOException {
int size = (int)lsize;
if (size != lsize)
throw new IOException("file too large: "+lsize);
CRC32 crc32 = _crc32;
if (_verbose > 1)
Utils.log.fine("Writing entry: "+name+" size="+size
+(deflateHint?" deflated":""));
if (_buf.length < size) {
int newSize = size;
while (newSize < _buf.length) {
newSize <<= 1;
if (newSize <= 0) {
newSize = size;
break;
}
}
_buf = new byte[newSize];
}
assert(_buf.length >= size);
int fillp = 0;
if (data0 != null) {
int size0 = data0.capacity();
data0.get(_buf, fillp, size0);
fillp += size0;
}
if (data1 != null) {
int size1 = data1.capacity();
data1.get(_buf, fillp, size1);
fillp += size1;
}
while (fillp < size) {
// Fill in rest of data from the stream itself.
int nr = in.read(_buf, fillp, size - fillp);
if (nr <= 0) throw new IOException("EOF at end of archive");
fillp += nr;
}
ZipEntry z = new ZipEntry(name);
z.setTime(mtime * 1000);
if (size == 0) {
z.setMethod(ZipOutputStream.STORED);
z.setSize(0);
z.setCrc(0);
z.setCompressedSize(0);
} else if (!deflateHint) {
z.setMethod(ZipOutputStream.STORED);
z.setSize(size);
z.setCompressedSize(size);
crc32.reset();
crc32.update(_buf, 0, size);
z.setCrc(crc32.getValue());
} else {
z.setMethod(Deflater.DEFLATED);
z.setSize(size);
}
j.putNextEntry(z);
if (size > 0)
j.write(_buf, 0, size);
j.closeEntry();
if (_verbose > 0) Utils.log.info("Writing " + Utils.zeString(z));
}
private ZipEntry createZipEntry(String name) {
ZipEntry result = new ZipEntry(name + JSON_FILE_EXTENSION);
result.setTime(0);
return result;
}
public static void main(String[] args) throws IOException {
// Create the class.
ClassWriter classWriter = new ClassWriter(0);
classWriter.visit(
V1_6,
ACC_PUBLIC + ACC_FINAL + ACC_SUPER,
"com/google/common/flogger/backend/PlatformProvider",
null,
"java/lang/Object",
null);
// Create the no-op constructor.
MethodVisitor methodVisitor = classWriter.visitMethod(ACC_PRIVATE, "<init>", "()V", null, null);
methodVisitor.visitCode();
methodVisitor.visitVarInsn(ALOAD, 0);
methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
methodVisitor.visitInsn(RETURN);
methodVisitor.visitMaxs(1, 1);
methodVisitor.visitEnd();
// Create the static getter method.
methodVisitor =
classWriter.visitMethod(
ACC_PUBLIC + ACC_STATIC,
"getPlatform",
"()Lcom/google/common/flogger/backend/Platform;",
null,
null);
// Try the different platforms.
for (String platformClass : PLATFORM_CLASSES) {
tryBlockForPlatform(methodVisitor, platformClass);
}
// Return null if no platform is found.
methodVisitor.visitInsn(ACONST_NULL);
methodVisitor.visitInsn(ARETURN);
methodVisitor.visitMaxs(2, 1);
methodVisitor.visitEnd();
// Finish creating the class.
classWriter.visitEnd();
// Write the class to the output file.
Path path = Paths.get(args[0]);
Files.createDirectories(path.getParent());
try (JarOutputStream jar =
new JarOutputStream(Files.newOutputStream(path, StandardOpenOption.CREATE_NEW))) {
ZipEntry entry = new ZipEntry("com/google/common/flogger/backend/PlatformProvider.class");
entry.setTime(0); // clear timestamp to ensure JAR is deterministic for cache during builds.
jar.putNextEntry(entry);
jar.write(classWriter.toByteArray());
jar.closeEntry();
}
}
private void writeEntry(JarOutputStream j, String name,
long mtime, long lsize, boolean deflateHint,
ByteBuffer data0, ByteBuffer data1) throws IOException {
int size = (int)lsize;
if (size != lsize)
throw new IOException("file too large: "+lsize);
CRC32 crc32 = _crc32;
if (_verbose > 1)
Utils.log.fine("Writing entry: "+name+" size="+size
+(deflateHint?" deflated":""));
if (_buf.length < size) {
int newSize = size;
while (newSize < _buf.length) {
newSize <<= 1;
if (newSize <= 0) {
newSize = size;
break;
}
}
_buf = new byte[newSize];
}
assert(_buf.length >= size);
int fillp = 0;
if (data0 != null) {
int size0 = data0.capacity();
data0.get(_buf, fillp, size0);
fillp += size0;
}
if (data1 != null) {
int size1 = data1.capacity();
data1.get(_buf, fillp, size1);
fillp += size1;
}
while (fillp < size) {
// Fill in rest of data from the stream itself.
int nr = in.read(_buf, fillp, size - fillp);
if (nr <= 0) throw new IOException("EOF at end of archive");
fillp += nr;
}
ZipEntry z = new ZipEntry(name);
z.setTime(mtime * 1000);
if (size == 0) {
z.setMethod(ZipOutputStream.STORED);
z.setSize(0);
z.setCrc(0);
z.setCompressedSize(0);
} else if (!deflateHint) {
z.setMethod(ZipOutputStream.STORED);
z.setSize(size);
z.setCompressedSize(size);
crc32.reset();
crc32.update(_buf, 0, size);
z.setCrc(crc32.getValue());
} else {
z.setMethod(Deflater.DEFLATED);
z.setSize(size);
}
j.putNextEntry(z);
if (size > 0)
j.write(_buf, 0, size);
j.closeEntry();
if (_verbose > 0) Utils.log.info("Writing " + Utils.zeString(z));
}