#Java - Code Snippets for '#.Time'

#Java - Code Snippets for '#.Time' - 28 code snippet(s) found

Sample 1. Scheduling task using java.util.timer

static {

   timer.schedule(new ScheduledTask(), 60000, 60000);

}



private static class Schedule extends TimerTask {

    @Override public void run() {

      //doSomething();

    }

}

_{Like Feedback java.util.timer java.util.TimerTask scheduling task java.lang Override}

Sample 2. Convert Time in milliseconds to Days

TimeUnit.DAYS.convert(timeinMs, TimeUnit.MILLISECONDS)

_{Like Feedback convert time in ms to days TimeUnit java.util.concurrent.TimeUnit}

Sample 3. Code Sample / Example / Snippet of java.time.Instant

        public Instant instant() {

            if ((tickNanos % 1000_000) == 0) {

                long millis = baseClock.millis();

                return Instant.ofEpochMilli(millis - Math.floorMod(millis, tickNanos / 1000_000L));

            }

            Instant instant = baseClock.instant();

            long nanos = instant.getNano();

            long adjust = Math.floorMod(nanos, tickNanos);

            return instant.minusNanos(adjust);

        }

_{Like Feedback java.time.Instant}

Sample 4. Code Sample / Example / Snippet of java.time.LocalTime

    public static LocalTime from(TemporalAccessor temporal) {

        Objects.requireNonNull(temporal, "temporal");

        LocalTime time = temporal.query(TemporalQueries.localTime());

        if (time == null) {

            throw new DateTimeException("Unable to obtain LocalTime from TemporalAccessor: " +

                    temporal + " of type " + temporal.getClass().getName());

        }

        return time;

    }

_{Like Feedback java.time.LocalTime}

Sample 5. Get Date using ZonedDateTime and LocalDateTime

ZonedDateTime zonedDatetime = ZonedDateTime.of(201, 1, 31, 14, 35, 12, 123, ZoneId.of("UTC-11"));

System.out.println(zonedDatetime.get(ChronoField.HOUR_OF_DAY));



LocalDateTime localDateTime = LocalDateTime.of(2015, 03, 10, 13, 36);

System.out.println(localDateTime);



ZonedDateTime zonedDatetime2 = ZonedDateTime.now(ZoneId.of("merica/Chicago"));

System.out.println(zonedDatetime2);



ZonedDateTime zonedDatetime3 = ZonedDateTime.of(localDateTime, ZoneId.of("America/Chicago"));

System.out.println(zonedDatetime3);

_{Like Feedback ZonedDateTime LocalDateTime ZonedDateTime.of LocalDateTime.of ZonedDateTime.now ZoneId ZoneId.of java.time.ZonedDateTime java.time java 8}

Sample 6. Enum implementing TemporalField

public enum MyChronoField implements TemporalField {



      NANO_OF_SECOND("NanoOfSecond", NANOS, SECONDS, ValueRange.of(12l,45l));





      private final String name;

       private final TemporalUnit baseUnit;

       private final TemporalUnit rangeUnit;

       private final ValueRange range;

       private final String displayNameKey;



       private MyChronoField(String name, TemporalUnit baseUnit, TemporalUnit rangeUnit, ValueRange range) {

           this.name = name;

           this.baseUnit = baseUnit;

           this.rangeUnit = rangeUnit;

           this.range = range;

           this.displayNameKey = null;

       }



       private MyChronoField(String name, TemporalUnit baseUnit, TemporalUnit rangeUnit,

               ValueRange range, String displayNameKey) {

           this.name = name;

           this.baseUnit = baseUnit;

           this.rangeUnit = rangeUnit;

           this.range = range;

           this.displayNameKey = displayNameKey;

       }

}

_{Like Feedback enum TemporalField java.time.temporal java.timejava.time.temporal.TemporalField}

Sample 7. Internal Implementation of ChronoField

public enum ChronoField implements TemporalField {

    NANO_OF_SECOND("NanoOfSecond", NANOS, SECONDS, ValueRange.of(0, 999_999_999)),

    NANO_OF_DAY("NanoOfDay", NANOS, DAYS, ValueRange.of(0, 86400L * 1000_000_000L - 1)),

    MICRO_OF_SECOND("MicroOfSecond", MICROS, SECONDS, ValueRange.of(0, 999_999)),

    MICRO_OF_DAY("MicroOfDay", MICROS, DAYS, ValueRange.of(0, 86400L * 1000_000L - 1)),

    MILLI_OF_SECOND("MilliOfSecond", MILLIS, SECONDS, ValueRange.of(0, 999)),

    MILLI_OF_DAY("MilliOfDay", MILLIS, DAYS, ValueRange.of(0, 86400L * 1000L - 1)),

    SECOND_OF_MINUTE("SecondOfMinute", SECONDS, MINUTES, ValueRange.of(0, 59), "second"),

    SECOND_OF_DAY("SecondOfDay", SECONDS, DAYS, ValueRange.of(0, 86400L - 1)),

    MINUTE_OF_HOUR("MinuteOfHour", MINUTES, HOURS, ValueRange.of(0, 59), "minute"),

    MINUTE_OF_DAY("MinuteOfDay", MINUTES, DAYS, ValueRange.of(0, (24 * 60) - 1)),

    HOUR_OF_AMPM("HourOfAmPm", HOURS, HALF_DAYS, ValueRange.of(0, 11)),

    CLOCK_HOUR_OF_AMPM("ClockHourOfAmPm", HOURS, HALF_DAYS, ValueRange.of(1, 12)),

    HOUR_OF_DAY("HourOfDay", HOURS, DAYS, ValueRange.of(0, 23), "hour"),

    CLOCK_HOUR_OF_DAY("ClockHourOfDay", HOURS, DAYS, ValueRange.of(1, 24)),

    AMPM_OF_DAY("AmPmOfDay", HALF_DAYS, DAYS, ValueRange.of(0, 1), "dayperiod"),

    DAY_OF_WEEK("DayOfWeek", DAYS, WEEKS, ValueRange.of(1, 7), "weekday"),

    ALIGNED_DAY_OF_WEEK_IN_MONTH("AlignedDayOfWeekInMonth", DAYS, WEEKS, ValueRange.of(1, 7)),

    ALIGNED_DAY_OF_WEEK_IN_YEAR("AlignedDayOfWeekInYear", DAYS, WEEKS, ValueRange.of(1, 7)),

    DAY_OF_MONTH("DayOfMonth", DAYS, MONTHS, ValueRange.of(1, 28, 31), "day"),

    DAY_OF_YEAR("DayOfYear", DAYS, YEARS, ValueRange.of(1, 365, 366)),

    EPOCH_DAY("EpochDay", DAYS, FOREVER, ValueRange.of((long) (Year.MIN_VALUE * 365.25), (long) (Year.MAX_VALUE * 365.25))),

    ALIGNED_WEEK_OF_MONTH("AlignedWeekOfMonth", WEEKS, MONTHS, ValueRange.of(1, 4, 5)),

    ALIGNED_WEEK_OF_YEAR("AlignedWeekOfYear", WEEKS, YEARS, ValueRange.of(1, 53)),

    MONTH_OF_YEAR("MonthOfYear", MONTHS, YEARS, ValueRange.of(1, 12), "month"),

    PROLEPTIC_MONTH("ProlepticMonth", MONTHS, FOREVER, ValueRange.of(Year.MIN_VALUE * 12L, Year.MAX_VALUE * 12L + 11)),

    YEAR_OF_ERA("YearOfEra", YEARS, FOREVER, ValueRange.of(1, Year.MAX_VALUE, Year.MAX_VALUE + 1)),

    YEAR("Year", YEARS, FOREVER, ValueRange.of(Year.MIN_VALUE, Year.MAX_VALUE), "year"),

    ERA("Era", ERAS, FOREVER, ValueRange.of(0, 1), "era"),

    INSTANT_SECONDS("InstantSeconds", SECONDS, FOREVER, ValueRange.of(Long.MIN_VALUE, Long.MAX_VALUE)),

    OFFSET_SECONDS("OffsetSeconds", SECONDS, FOREVER, ValueRange.of(-18 * 3600, 18 * 3600));



    private final String name;

    private final TemporalUnit baseUnit;

    private final TemporalUnit rangeUnit;

    private final ValueRange range;

    private final String displayNameKey;



    private ChronoField(String name, TemporalUnit baseUnit, TemporalUnit rangeUnit, ValueRange range) {

        this.name = name;

        this.baseUnit = baseUnit;

        this.rangeUnit = rangeUnit;

        this.range = range;

        this.displayNameKey = null;

    }



    private ChronoField(String name, TemporalUnit baseUnit, TemporalUnit rangeUnit,

            ValueRange range, String displayNameKey) {

        this.name = name;

        this.baseUnit = baseUnit;

        this.rangeUnit = rangeUnit;

        this.range = range;

        this.displayNameKey = displayNameKey;

    }



    @Override

    public String getDisplayName(Locale locale) {

        Objects.requireNonNull(locale, "locale");

        if (displayNameKey == null) {

            return name;

        }



        LocaleResources lr = LocaleProviderAdapter.getResourceBundleBased()

                                    .getLocaleResources(locale);

        ResourceBundle rb = lr.getJavaTimeFormatData();

        String key = "field." + displayNameKey;

        return rb.containsKey(key) ? rb.getString(key) : name;

    }



    @Override

    public TemporalUnit getBaseUnit() {

        return baseUnit;

    }



    @Override

    public TemporalUnit getRangeUnit() {

        return rangeUnit;

    }



    @Override

    public ValueRange range() {

        return range;

    }



    @Override

    public boolean isDateBased() {

        return ordinal() >= DAY_OF_WEEK.ordinal() && ordinal() <= ERA.ordinal();

    }



    @Override

    public boolean isTimeBased() {

        return ordinal() < DAY_OF_WEEK.ordinal();

    }



    public long checkValidValue(long value) {

        return range().checkValidValue(value, this);

    }



    public int checkValidIntValue(long value) {

        return range().checkValidIntValue(value, this);

    }



    @Override

    public boolean isSupportedBy(TemporalAccessor temporal) {

        return temporal.isSupported(this);

    }



    @Override

    public ValueRange rangeRefinedBy(TemporalAccessor temporal) {

        return temporal.range(this);

    }



    @Override

    public long getFrom(TemporalAccessor temporal) {

        return temporal.getLong(this);

    }



    @SuppressWarnings("unchecked")

    @Override

    public <R extends Temporal> R adjustInto(R temporal, long newValue) {

        return (R) temporal.with(this, newValue);

    }



    @Override

    public String toString() {

        return name;

    }



}

_{Like Feedback chronofield temporalfield java 8 java.time.temporal.TemporalField}

Sample 8. Internal Implementation of MinguoEra

public enum MinguoEra implements Era {

    BEFORE_ROC,

    ROC;



    public static MinguoEra of(int minguoEra) {

        switch (minguoEra) {

            case 0:

                return BEFORE_ROC;

            case 1:

                return ROC;

            default:

                throw new DateTimeException("Invalid era: " + minguoEra);

        }

    }



    @Override

    public int getValue() {

        return ordinal();

    }



}

_{Like Feedback MinguoEra java.time java.time.chrono internal implementation enum switch throw exception throw}

Sample 9. Internal Implementation of java.time.chrono.era

public interface Era extends TemporalAccessor, TemporalAdjuster {

    int getValue();



    @Override

    default boolean isSupported(TemporalField field) {

        if (field instanceof ChronoField) {

            return field == ERA;

        }

        return field != null && field.isSupportedBy(this);

    }



    @Override  // override for Javadoc

    default ValueRange range(TemporalField field) {

        return TemporalAccessor.super.range(field);

    }



    @Override  // override for Javadoc and performance

    default int get(TemporalField field) {

        if (field == ERA) {

            return getValue();

        }

        return TemporalAccessor.super.get(field);

    }



    @Override

    default long getLong(TemporalField field) {

        if (field == ERA) {

            return getValue();

        } else if (field instanceof ChronoField) {

            throw new UnsupportedTemporalTypeException("Unsupported field: " + field);

        }

        return field.getFrom(this);

    }



    @SuppressWarnings("unchecked")

    @Override

    default <R> R query(TemporalQuery<R> query) {

        if (query == TemporalQueries.precision()) {

            return (R) ERAS;

        }

        return TemporalAccessor.super.query(query);

    }



    @Override

    default Temporal adjustInto(Temporal temporal) {

        return temporal.with(ERA, getValue());

    }



    default String getDisplayName(TextStyle style, Locale locale) {

        return new DateTimeFormatterBuilder().appendText(ERA, style).toFormatter(locale).format(this);

    }

}

_{Like Feedback era java.time.TemporalAccessor java.time.TemporalAdjuster java.time.chrono default methods}

Sample 10. Usage of org.joda.time.DateMidnight

DateMidnight currentDate = new DateMidnight();

DateMidnight dateafterAMonth = currentDate.plusMonths(1);

Date javaSedateAfterAMonth = dateafterAMonth.toDate();

_{Like Feedback org.joda.time.DateMidnight java.util.Date Date Add month to Date}

Sample 11. Use java.time.format.DateTimeFormatter to Parse date in the format YYYYMMDD+HHmmss

DateTimeFormatter dateTimeFormatter = new DateTimeFormatterBuilder()

          .parseCaseInsensitive()

          .appendValue(YEAR, 4)

          .appendValue(MONTH_OF_YEAR, 2)

          .appendValue(DAY_OF_MONTH, 2)

          .appendOffset("+HHMMss", "Z")

          .toFormatter();



TemporalAccessor temporal = null;



try {

           temporal = dateTimeFormatter.parse("2016101+235700");

           System.out.println(temporal.toString()); // prints {OffsetSeconds=86220},ISO resolved to 2016-01-01

} catch (DateTimeParseException ex){

           System.out.println("Error parsing date");

}

_{Like Feedback DateTimeFormatter Parse Date in Java 8 Parse date using DateTimeFormatter and DateTimeFormatterBuilder}

Sample 12. Get the Date object using the TimeZone

TimeZone zone = (TimeZone.getDefault().getRawOffset() == EET.getRawOffset() ? EST : EET);

Date expectedZone = createCalendar(zone, 20051231, 0).getTime();

_{Like Feedback TimeZone java.util.TimeZone Date Calendar}

Sample 13. Code Sample / Example / Snippet of java.time.zone.ZoneRules

    public static LocalDateTime ofInstant(Instant instant, ZoneId zone) {

        Objects.requireNonNull(instant, "instant");

        Objects.requireNonNull(zone, "zone");

        ZoneRules rules = zone.getRules();

        ZoneOffset offset = rules.getOffset(instant);

        return ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset);

    }

_{Like Feedback java.time.zone.ZoneRules}

Sample 14. Code Sample / Example / Snippet of java.time.temporal.ChronoUnit

    public LocalDateTime plus(long amountToAdd, TemporalUnit unit) {

        if (unit instanceof ChronoUnit) {

            ChronoUnit f = (ChronoUnit) unit;

            switch (f) {

                case NANOS: return plusNanos(amountToAdd);

                case MICROS: return plusDays(amountToAdd / MICROS_PER_DAY).plusNanos((amountToAdd % MICROS_PER_DAY) * 1000);

                case MILLIS: return plusDays(amountToAdd / MILLIS_PER_DAY).plusNanos((amountToAdd % MILLIS_PER_DAY) * 1000_000);

                case SECONDS: return plusSeconds(amountToAdd);

                case MINUTES: return plusMinutes(amountToAdd);

                case HOURS: return plusHours(amountToAdd);

                case HALF_DAYS: return plusDays(amountToAdd / 256).plusHours((amountToAdd % 256) * 12);  // no overflow (256 is multiple of 2)

            }

            return with(date.plus(amountToAdd, unit), time);

        }

        return unit.addTo(this, amountToAdd);

    }

_{Like Feedback java.time.temporal.ChronoUnit}

Sample 15. Code Sample / Example / Snippet of java.time.zone.ZoneOffsetTransition

    public static ZonedDateTime ofLocal(LocalDateTime localDateTime, ZoneId zone, ZoneOffset preferredOffset) {

        Objects.requireNonNull(localDateTime, "localDateTime");

        Objects.requireNonNull(zone, "zone");

        if (zone instanceof ZoneOffset) {

            return new ZonedDateTime(localDateTime, (ZoneOffset) zone, zone);

        }

        ZoneRules rules = zone.getRules();

        List<ZoneOffset> validOffsets = rules.getValidOffsets(localDateTime);

        ZoneOffset offset;

        if (validOffsets.size() == 1) {

            offset = validOffsets.get(0);

        } else if (validOffsets.size() == 0) {

            ZoneOffsetTransition trans = rules.getTransition(localDateTime);

            localDateTime = localDateTime.plusSeconds(trans.getDuration().getSeconds());

            offset = trans.getOffsetAfter();

        } else {

            if (preferredOffset != null && validOffsets.contains(preferredOffset)) {

                offset = preferredOffset;

            } else {

                offset = Objects.requireNonNull(validOffsets.get(0), "offset");  // protect against bad ZoneRules

            }

        }

        return new ZonedDateTime(localDateTime, offset, zone);

    }

_{Like Feedback java.time.zone.ZoneOffsetTransition}

Sample 16. Code Sample / Example / Snippet of java.time.LocalDateTime

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }

        if (obj instanceof LocalDateTime) {

            LocalDateTime other = (LocalDateTime) obj;

            return date.equals(other.date) && time.equals(other.time);

        }

        return false;

    }

_{Like Feedback java.time.LocalDateTime}

Sample 17. Code Sample / Example / Snippet of java.time.ZoneOffset

public static LocalTime now(Clock clock) {



        Objects.requireNonNull(clock, "clock");



        final Instant now = clock.instant();  // called once



        ZoneOffset offset = clock.getZone().getRules().getOffset(now);



        long localSecond = now.getEpochSecond() + offset.getTotalSeconds();  // overflow caught later



        int secsOfDay = (int) Math.floorMod(localSecond, SECONDS_PER_DAY);



        return ofNanoOfDay(secsOfDay * NANOS_PER_SECOND + now.getNano());



    }

_{Like Feedback java.time.ZoneOffset}

Sample 18. Code Sample / Example / Snippet of java.time.ZoneId

    private void readObject(ObjectInputStream s) throws InvalidObjectException {

        throw new InvalidObjectException("Deserialization via serialization delegate");

    }



    void writeExternal(DataOutput out) throws IOException {

        dateTime.writeExternal(out);

        offset.writeExternal(out);

        zone.write(out);

    }



    static ZonedDateTime readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

        LocalDateTime dateTime = LocalDateTime.readExternal(in);

        ZoneOffset offset = ZoneOffset.readExternal(in);

        ZoneId zone = (ZoneId) Ser.read(in);

        return ZonedDateTime.ofLenient(dateTime, offset, zone);

    }

_{Like Feedback java.time.ZoneId}

Sample 19. Code Sample / Example / Snippet of java.time.ZonedDateTime

    public long until(Temporal endExclusive, TemporalUnit unit) {

        ZonedDateTime end = ZonedDateTime.from(endExclusive);

        if (unit instanceof ChronoUnit) {

            end = end.withZoneSameInstant(zone);

            if (unit.isDateBased()) {

                return dateTime.until(end.dateTime, unit);

            } else {

                return toOffsetDateTime().until(end.toOffsetDateTime(), unit);

            }

        }

        return unit.between(this, end);

    }

_{Like Feedback java.time.ZonedDateTime}

Sample 20. Code Sample / Example / Snippet of java.time.Year

private ZoneOffsetTransition[] findTransitionArray(int year) {



        Integer yearObj = year;  



        ZoneOffsetTransition[] transArray = lastRulesCache.get(yearObj);



        if (transArray != null) {



            return transArray;



        }



        ZoneOffsetTransitionRule[] ruleArray = lastRules;



        transArray  = new ZoneOffsetTransition[ruleArray.length];



        for (int i = 0; i < ruleArray.length; i++) {



            transArray[i] = ruleArray[i].createTransition(year);



        }



        if (year < LAST_CACHED_YEAR) {



            lastRulesCache.putIfAbsent(yearObj, transArray);



        }



        return transArray;



    }

_{Like Feedback java.time.Year}

Sample 21. Code Sample / Example / Snippet of java.time.LocalDate

    public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute) {

        LocalDate date = LocalDate.of(year, month, dayOfMonth);

        LocalTime time = LocalTime.of(hour, minute);

        return new LocalDateTime(date, time);

    }

_{Like Feedback java.time.LocalDate}

Sample 22. Code Sample / Example / Snippet of java.time.Month

    public static LocalDate ofYearDay(int year, int dayOfYear) {

        YEAR.checkValidValue(year);

        DAY_OF_YEAR.checkValidValue(dayOfYear);

        boolean leap = IsoChronology.INSTANCE.isLeapYear(year);

        if (dayOfYear == 366 && leap == false) {

            throw new DateTimeException("Invalid date 'DayOfYear 366' as '" + year + "' is not a leap year");

        }

        Month moy = Month.of((dayOfYear - 1) / 31 + 1);

        int monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;

        if (dayOfYear > monthEnd) {

            moy = moy.plus(1);

        }

        int dom = dayOfYear - moy.firstDayOfYear(leap) + 1;

        return new LocalDate(year, moy.getValue(), dom);

    }

_{Like Feedback java.time.Month}

Sample 23. Code Sample / Example / Snippet of java.time.Period

    public Period plus(TemporalAmount amountToAdd) {

        Period isoAmount = Period.from(amountToAdd);

        return create(

                Math.addExact(years, isoAmount.years),

                Math.addExact(months, isoAmount.months),

                Math.addExact(days, isoAmount.days));

    }

_{Like Feedback java.time.Period}

Sample 24. Code Sample / Example / Snippet of java.time.chrono.Chronology

        public ChronoLocalDate resolve(

                Map<TemporalField, Long> fieldValues, TemporalAccessor partialTemporal, ResolverStyle resolverStyle) {

            long value = fieldValues.remove(this);

            Chronology chrono = Chronology.from(partialTemporal);

            if (resolverStyle == ResolverStyle.LENIENT) {

                return chrono.dateEpochDay(Math.subtractExact(value, offset));

            }

            range().checkValidValue(value, this);

            return chrono.dateEpochDay(value - offset);

        }

_{Like Feedback java.time.chrono.Chronology}

Sample 25. Code Sample / Example / Snippet of java.time.temporal.ValueRange

        private int localizedWeekBasedYear(TemporalAccessor temporal) {

            int dow = localizedDayOfWeek(temporal);

            int year = temporal.get(YEAR);

            int doy = temporal.get(DAY_OF_YEAR);

            int offset = startOfWeekOffset(doy, dow);

            int week = computeWeek(offset, doy);

            if (week == 0) {

                return year - 1;

            } else {

                ValueRange dayRange = temporal.range(DAY_OF_YEAR);

                int yearLen = (int)dayRange.getMaximum();

                int newYearWeek = computeWeek(offset, yearLen + weekDef.getMinimalDaysInFirstWeek());

                if (week >= newYearWeek) {

                    return year + 1;

                }

            }

            return year;

        }

_{Like Feedback java.time.temporal.ValueRange}

Sample 26. Code Sample / Example / Snippet of java.util.TimeZone

  private static final FastDateFormat TIME_FORMAT_TIMESTAMP;



  static {

    TimeZone gmt = TimeZone.getTimeZone("GMT");

    TIME_FORMAT_DATE = FastDateFormat.getInstance("yyyy-MM-dd", gmt);

    TIME_FORMAT_TIME = FastDateFormat.getInstance("HH:mm:ss", gmt);

    TIME_FORMAT_TIMESTAMP =

        FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss", gmt);

  }

_{Like Feedback java.util.TimeZone}

Sample 27. Code Sample / Example / Snippet of org.apache.calcite.avatica.util.TimeUnitRange

  private void checkTimestampString(String s, long d) {

    assertThat(unixTimestampToString(d), equalTo(s));

    assertThat(timestampStringToUnixDate(s), equalTo(d));

  }



  @Test public void testIntervalYearMonthToString() {

    TimeUnitRange range = TimeUnitRange.YEAR_TO_MONTH;

    assertEquals("+0-00", intervalYearMonthToString(0, range));

    assertEquals("+1-00", intervalYearMonthToString(12, range));

    assertEquals("+1-01", intervalYearMonthToString(13, range));

    assertEquals("-1-01", intervalYearMonthToString(-13, range));

  }

_{Like Feedback org.apache.calcite.avatica.util.TimeUnitRange}

Sample 28. Code Sample / Example / Snippet of java.util.Timer

    public void shutdown(long delay) {

        Timer timer = new Timer();

        timer.schedule(new TimerTask() {

            @Override

            public void run() {

                try {

                    m_context.getBundle(0).stop();

                }

                catch (BundleException e) {

                    e.printStackTrace();

                }

            }

        }, delay);

    }

_{Like Feedback java.util.Timer}

Search Java Code Snippets