InputStream InputStream = loader.getResourceAsStream(ipDirInJar + File.separator + dexFileName);

/Library/Java/JavaVirtualMachines/openjdk-8.jdk/Contents/Home/src.zip!/java/util/zip/ZipFile.java:335

private static native long getEntry(long jzfile, byte[] name, boolean addSlash);

package me.tianshuang;

public class Test {

    public static void main(String[] args) {
        System.out.println(System.getProperty("java.class.path"));
    }

}

class GcMetricsNotificationListener implements NotificationListener {
    private final MeterRegistry registry;

    GcMetricsNotificationListener(MeterRegistry registry) {
        this.registry = registry;
    }

    @Override
    public void handleNotification(Notification notification, Object ref) {
        CompositeData cd = (CompositeData) notification.getUserData();
        GarbageCollectionNotificationInfo notificationInfo = GarbageCollectionNotificationInfo.from(cd);

        String gcCause = notificationInfo.getGcCause();
        String gcAction = notificationInfo.getGcAction();
        GcInfo gcInfo = notificationInfo.getGcInfo();
        long duration = gcInfo.getDuration();
        if (isConcurrentPhase(gcCause, notificationInfo.getGcName())) {
            Timer.builder("jvm.gc.concurrent.phase.time")
                    .tags(tags)
                    .tags("action", gcAction, "cause", gcCause)
                    .description("Time spent in concurrent phase")
                    .register(registry)
                    .record(duration, TimeUnit.MILLISECONDS);
        } else {
            Timer.builder("jvm.gc.pause")
                    .tags(tags)
                    .tags("action", gcAction, "cause", gcCause)
                    .description("Time spent in GC pause")
                    .register(registry)
                    .record(duration, TimeUnit.MILLISECONDS);
        }

        final Map<String, MemoryUsage> before = gcInfo.getMemoryUsageBeforeGc();
        final Map<String, MemoryUsage> after = gcInfo.getMemoryUsageAfterGc();

        countPoolSizeDelta(before, after);

        final long longLivedBefore = longLivedPoolNames.stream().mapToLong(pool -> before.get(pool).getUsed()).sum();
        final long longLivedAfter = longLivedPoolNames.stream().mapToLong(pool -> after.get(pool).getUsed()).sum();
        if (isGenerationalGc) {
            final long delta = longLivedAfter - longLivedBefore;
            if (delta > 0L) {
                promotedBytes.increment(delta);
            }
        }

        // Some GC implementations such as G1 can reduce the old gen size as part of a minor GC. To track the
        // live data size we record the value if we see a reduction in the long-lived heap size or
        // after a major/non-generational GC.
        if (longLivedAfter < longLivedBefore || shouldUpdateDataSizeMetrics(notificationInfo.getGcName())) {
            liveDataSize.set(longLivedAfter);
            maxDataSize.set(longLivedPoolNames.stream().mapToLong(pool -> after.get(pool).getMax()).sum());
        }
    }

    private void countPoolSizeDelta(Map<String, MemoryUsage> before, Map<String, MemoryUsage> after) {
        if (allocationPoolName == null) {
            return;
        }
        final long beforeBytes = before.get(allocationPoolName).getUsed();
        final long afterBytes = after.get(allocationPoolName).getUsed();
        final long delta = beforeBytes - allocationPoolSizeAfter.get();
        allocationPoolSizeAfter.set(afterBytes);
        if (delta > 0L) {
            allocatedBytes.increment(delta);
        }
    }

    private boolean shouldUpdateDataSizeMetrics(String gcName) {
        return nonGenerationalGcShouldUpdateDataSize(gcName) || isMajorGenerationalGc(gcName);
    }

    private boolean isMajorGenerationalGc(String gcName) {
        return GcGenerationAge.fromGcName(gcName) == GcGenerationAge.OLD;
    }

    private boolean nonGenerationalGcShouldUpdateDataSize(String gcName) {
        return !isGenerationalGc
                // Skip Shenandoah and ZGC gc notifications with the name Pauses due to missing memory pool size info
                && !gcName.endsWith("Pauses");
    }
}

// Implementation of "dumpheap" command.
// See also: HeapDumpDCmd class
//
// Input arguments :-
//   arg0: Name of the dump file
//   arg1: "-live" or "-all"
jint dump_heap(AttachOperation* op, outputStream* out) {
  const char* path = op->arg(0);
  if (path == NULL || path[0] == '\0') {
    out->print_cr("No dump file specified");
  } else {
    bool live_objects_only = true;   // default is true to retain the behavior before this change is made
    const char* arg1 = op->arg(1);
    if (arg1 != NULL && (strlen(arg1) > 0)) {
      if (strcmp(arg1, "-all") != 0 && strcmp(arg1, "-live") != 0) {
        out->print_cr("Invalid argument to dumpheap operation: %s", arg1);
        return JNI_ERR;
      }
      live_objects_only = strcmp(arg1, "-live") == 0;
    }

    // Request a full GC before heap dump if live_objects_only = true
    // This helps reduces the amount of unreachable objects in the dump
    // and makes it easier to browse.
    HeapDumper dumper(live_objects_only /* request GC */);
    int res = dumper.dump(op->arg(0));
    if (res == 0) {
      out->print_cr("Heap dump file created");
    } else {
      // heap dump failed
      ResourceMark rm;
      char* error = dumper.error_as_C_string();
      if (error == NULL) {
        out->print_cr("Dump failed - reason unknown");
      } else {
        out->print_cr("%s", error);
      }
    }
  }
  return JNI_OK;
}