java.time.ZoneId#getAvailableZoneIds ( )源码实例Demo

@Test
public void testDates() throws StandardException {

    DatabaseContext dc = (DatabaseContext) ContextService.getContext(DatabaseContext.CONTEXT_ID);
    LocaleFinder localeFinder = (dc == null) ? null : dc.getDatabase();
    DescriptorSerializer dateDescriptorSerializer = DateV4DescriptorSerializer.INSTANCE_FACTORY.newInstance();

    try {
        // Encoding/decoding of dates should not be timezone-sensitive.
        for (String zId : ZoneId.getAvailableZoneIds()) {
            ZoneId zoneId = ZoneId.of(zId);
            for (String date : dates)
                testSingleDate(date, localeFinder, zoneId, dateDescriptorSerializer);
        }
    } catch (Exception e) {
        Assert.fail("Exception while testing Date encoding/decoding.");
    }
}
 

@Test
public void testPerformance() {
    Set<String> allZones = ZoneId.getAvailableZoneIds();
    List<String> zoneList = new ArrayList<>(allZones);
    Collections.sort(zoneList);
    List<ZoneId> zones = new ArrayList<>(zoneList.size());
    List<TimeZoneRulesImpl> zoneRules = new ArrayList<>(zoneList.size());

    for (String z : zoneList) {
        ZoneId zone = ZoneId.of(z);
        zones.add(zone);
        zoneRules.add(new TimeZoneRulesImpl(zone.getRules()));
    }

    long millis = Timestamps.toMicros(1900, 1, 1, 0, 0);
    long deadline = Timestamps.toMicros(2615, 12, 31, 0, 0);

    while (millis < deadline) {
        for (int i = 0, n = zones.size(); i < n; i++) {
            zoneRules.get(i).getOffset(millis);
        }
        millis += Timestamps.DAY_MICROS;
    }
}
 

public TimeZoneRuleFactory() {
    int index = 0;
    for (String z : ZoneId.getAvailableZoneIds()) {
        ruleList.add(new TimeZoneRulesImpl(ZoneId.of(z).getRules()));
        ruleMap.put(z, index++);
    }

    for (Map.Entry<String, String> e : ZoneId.SHORT_IDS.entrySet()) {
        String key = e.getKey();
        String alias = e.getValue();

        // key already added somehow?
        int i = ruleMap.get(key);
        if (i == -1) {
            // no, good, add
            i = ruleMap.get(alias);
            if (i == -1) {
                // this could be fixed offset, try parsing value as one
                long offset = Timestamps.parseOffset(alias, 0, alias.length());
                if (offset != Long.MIN_VALUE) {
                    ruleList.add(new FixedTimeZoneRule(Numbers.decodeLowInt(offset) * Timestamps.MILLI_MICROS));
                    ruleMap.put(key, index++);
                }
            } else {
                ruleMap.put(key, i);
            }
        }
    }
}
 

@Override
public JsonResult execute() {
    String tzVersion = ZoneRulesProvider.getVersions("UTC").firstKey();
    Instant now = Instant.now();
    Map<String, Integer> tzOffsets = new TreeMap<>();
    for (String tz : ZoneId.getAvailableZoneIds()) {
        if (!tz.contains("SystemV")) {
            int offset = ZoneId.of(tz).getRules().getOffset(now).getTotalSeconds();
            tzOffsets.put(tz, offset);
        }
    }
    TimeZonesData output = new TimeZonesData(tzVersion, tzOffsets);
    return new JsonResult(output);
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

@Test
public void test_adjustInto_ZonedDateTime() {
    ZoneOffset base = ZoneOffset.ofHoursMinutesSeconds(1, 1, 1);
    for (String zoneId : ZoneId.getAvailableZoneIds()) {
        //Do not change offset of ZonedDateTime after adjustInto()
        ZonedDateTime zonedDateTime_target = ZonedDateTime.of(LocalDate.of(1909, 2, 2), LocalTime.of(10, 10, 10), ZoneId.of(zoneId));
        ZonedDateTime zonedDateTime_result = (ZonedDateTime)(base.adjustInto(zonedDateTime_target));
        assertEquals(zonedDateTime_target.getOffset(), zonedDateTime_result.getOffset());

        OffsetDateTime offsetDateTime_target = zonedDateTime_target.toOffsetDateTime();
        OffsetDateTime offsetDateTime_result = (OffsetDateTime)(base.adjustInto(offsetDateTime_target));
        assertEquals(base, offsetDateTime_result.getOffset());
    }
}
 

@Test
public void test_adjustInto_ZonedDateTime() {
    ZoneOffset base = ZoneOffset.ofHoursMinutesSeconds(1, 1, 1);
    for (String zoneId : ZoneId.getAvailableZoneIds()) {
        //Do not change offset of ZonedDateTime after adjustInto()
        ZonedDateTime zonedDateTime_target = ZonedDateTime.of(LocalDate.of(1909, 2, 2), LocalTime.of(10, 10, 10), ZoneId.of(zoneId));
        ZonedDateTime zonedDateTime_result = (ZonedDateTime)(base.adjustInto(zonedDateTime_target));
        assertEquals(zonedDateTime_target.getOffset(), zonedDateTime_result.getOffset());

        OffsetDateTime offsetDateTime_target = zonedDateTime_target.toOffsetDateTime();
        OffsetDateTime offsetDateTime_result = (OffsetDateTime)(base.adjustInto(offsetDateTime_target));
        assertEquals(base, offsetDateTime_result.getOffset());
    }
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

private static Object randomValue(Class<?> type) {
    var random = ThreadLocalRandom.current();
    if (type == UUID.class) {
        return UUID.randomUUID();
    }
    if (type == LocalDate.class) {
        return LocalDate.of(
                random.nextInt(2000, 2100),
                random.nextInt(Month.JANUARY.getValue(), Month.DECEMBER.getValue() + 1),
                random.nextInt(1, Month.FEBRUARY.minLength() + 1));
    }
    if (type == Money.class) {
        return Money.of(
                random.nextDouble(0, 1000),
                pickRandom(Monetary.getCurrencies()));
    }
    if (type == Instant.class) {
        return Instant.ofEpochMilli(random.nextLong());
    }
    if (type == ZonedDateTime.class) {
        var zoneIds = ZoneId.getAvailableZoneIds();
        zoneIds.remove("GMT0"); // XXX: cannot be parsed by java.time.format.DateTimeFormatterBuilder.appendZoneRegionId - fixed in Java 9 https://bugs.openjdk.java.net/browse/JDK-8138664
        var zoneId = ZoneId.of(pickRandom(zoneIds));
        return Instant.ofEpochMilli(random.nextLong()).atZone(zoneId);
    }
    if (type == String.class) {
        return RandomStringUtils.randomAlphanumeric(random.nextInt(10));
    }
    if (type == int.class) {
        return random.nextInt();
    }
    if (type == Class.class) {
        return pickRandom(Arrays.asList(Integer.class, Long.class, Float.class, Double.class));
    }
    throw new IllegalArgumentException("Unsupported type: " + type);
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

@Test
public void test_adjustInto_ZonedDateTime() {
    ZoneOffset base = ZoneOffset.ofHoursMinutesSeconds(1, 1, 1);
    for (String zoneId : ZoneId.getAvailableZoneIds()) {
        //Do not change offset of ZonedDateTime after adjustInto()
        ZonedDateTime zonedDateTime_target = ZonedDateTime.of(LocalDate.of(1909, 2, 2), LocalTime.of(10, 10, 10), ZoneId.of(zoneId));
        ZonedDateTime zonedDateTime_result = (ZonedDateTime)(base.adjustInto(zonedDateTime_target));
        assertEquals(zonedDateTime_target.getOffset(), zonedDateTime_result.getOffset());

        OffsetDateTime offsetDateTime_target = zonedDateTime_target.toOffsetDateTime();
        OffsetDateTime offsetDateTime_result = (OffsetDateTime)(base.adjustInto(offsetDateTime_target));
        assertEquals(base, offsetDateTime_result.getOffset());
    }
}
 

@Test
public void test_adjustInto_ZonedDateTime() {
    ZoneOffset base = ZoneOffset.ofHoursMinutesSeconds(1, 1, 1);
    for (String zoneId : ZoneId.getAvailableZoneIds()) {
        //Do not change offset of ZonedDateTime after adjustInto()
        ZonedDateTime zonedDateTime_target = ZonedDateTime.of(LocalDate.of(1909, 2, 2), LocalTime.of(10, 10, 10), ZoneId.of(zoneId));
        ZonedDateTime zonedDateTime_result = (ZonedDateTime)(base.adjustInto(zonedDateTime_target));
        assertEquals(zonedDateTime_target.getOffset(), zonedDateTime_result.getOffset());

        OffsetDateTime offsetDateTime_target = zonedDateTime_target.toOffsetDateTime();
        OffsetDateTime offsetDateTime_result = (OffsetDateTime)(base.adjustInto(offsetDateTime_target));
        assertEquals(base, offsetDateTime_result.getOffset());
    }
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

@Test
public void test_getAvailableGroupIds() {
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds.contains("Europe/London"), true);
    zoneIds.clear();
    assertEquals(zoneIds.size(), 0);
    Set<String> zoneIds2 = ZoneId.getAvailableZoneIds();
    assertEquals(zoneIds2.contains("Europe/London"), true);
}
 

public static List<String> localTimeToAllTimeZones8() {

        List<String> result = new ArrayList<>();
        Set<String> zoneIds = ZoneId.getAvailableZoneIds();

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MMM-dd'T'HH:mm:ss a Z");

        ZonedDateTime zlt = ZonedDateTime.now();

        zoneIds.forEach((zoneId) -> {
            result.add(zlt.format(formatter) + " in " + zoneId + " is "
                    + zlt.withZoneSameInstant(ZoneId.of(zoneId)).format(formatter));
        });

        return result;
    }
 

@Test
public void whenRequestingZones_thenAtLeastOneIsReturned() {
    Set<String> allZoneIds = ZoneId.getAvailableZoneIds();

    assertThat(allZoneIds.size()).isGreaterThan(1);
}