001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.commons.lang3; 018 019import org.apache.commons.lang3.math.NumberUtils; 020 021/** 022 * An enum representing all the versions of the Java specification. 023 * This is intended to mirror available values from the 024 * <em>java.specification.version</em> System property. 025 * 026 * @since 3.0 027 */ 028public enum JavaVersion { 029 030 /** 031 * The Java version reported by Android. This is not an official Java version number. 032 */ 033 JAVA_0_9(1.5f, "0.9"), 034 035 /** 036 * Java 1.1. 037 */ 038 JAVA_1_1(1.1f, "1.1"), 039 040 /** 041 * Java 1.2. 042 */ 043 JAVA_1_2(1.2f, "1.2"), 044 045 /** 046 * Java 1.3. 047 */ 048 JAVA_1_3(1.3f, "1.3"), 049 050 /** 051 * Java 1.4. 052 */ 053 JAVA_1_4(1.4f, "1.4"), 054 055 /** 056 * Java 1.5. 057 */ 058 JAVA_1_5(1.5f, "1.5"), 059 060 /** 061 * Java 1.6. 062 */ 063 JAVA_1_6(1.6f, "1.6"), 064 065 /** 066 * Java 1.7. 067 */ 068 JAVA_1_7(1.7f, "1.7"), 069 070 /** 071 * Java 1.8. 072 */ 073 JAVA_1_8(1.8f, "1.8"), 074 075 /** 076 * Java 1.9. 077 * 078 * @deprecated As of release 3.5, replaced by {@link #JAVA_9} 079 */ 080 @Deprecated 081 JAVA_1_9(9.0f, "9"), 082 083 /** 084 * Java 9. 085 * 086 * @since 3.5 087 */ 088 JAVA_9(9.0f, "9"), 089 090 /** 091 * Java 10. 092 * 093 * @since 3.7 094 */ 095 JAVA_10(10.0f, "10"), 096 097 /** 098 * Java 11. 099 * 100 * @since 3.8 101 */ 102 JAVA_11(11.0f, "11"), 103 104 /** 105 * Java 12. 106 * 107 * @since 3.9 108 */ 109 JAVA_12(12.0f, "12"), 110 111 /** 112 * Java 13. 113 * 114 * @since 3.9 115 */ 116 JAVA_13(13.0f, "13"), 117 118 /** 119 * Java 14. 120 * 121 * @since 3.11 122 */ 123 JAVA_14(14.0f, "14"), 124 125 /** 126 * Java 15. 127 * 128 * @since 3.11 129 */ 130 JAVA_15(15.0f, "15"), 131 132 /** 133 * Java 16. 134 * 135 * @since 3.11 136 */ 137 JAVA_16(16.0f, "16"), 138 139 /** 140 * Java 17. 141 * 142 * @since 3.12.0 143 */ 144 JAVA_17(17.0f, "17"), 145 146 /** 147 * Java 18. 148 * 149 * @since 3.13.0 150 */ 151 JAVA_18(18.0f, "18"), 152 153 /** 154 * Java 19. 155 * 156 * @since 3.13.0 157 */ 158 JAVA_19(19.0f, "19"), 159 160 /** 161 * Java 20. 162 * 163 * @since 3.13.0 164 */ 165 JAVA_20(20, "20"), 166 167 /** 168 * Java 21. 169 * 170 * @since 3.13.0 171 */ 172 JAVA_21(21, "21"), 173 174 /** 175 * The most recent java version. Mainly introduced to avoid to break when a new version of Java is used. 176 */ 177 JAVA_RECENT(maxVersion(), Float.toString(maxVersion())); 178 179 /** 180 * Transforms the given string with a Java version number to the 181 * corresponding constant of this enumeration class. This method is used 182 * internally. 183 * 184 * @param versionStr the Java version as string 185 * @return the corresponding enumeration constant or <b>null</b> if the 186 * version is unknown 187 */ 188 static JavaVersion get(final String versionStr) { 189 if (versionStr == null) { 190 return null; 191 } 192 switch (versionStr) { 193 case "0.9": 194 return JAVA_0_9; 195 case "1.1": 196 return JAVA_1_1; 197 case "1.2": 198 return JAVA_1_2; 199 case "1.3": 200 return JAVA_1_3; 201 case "1.4": 202 return JAVA_1_4; 203 case "1.5": 204 return JAVA_1_5; 205 case "1.6": 206 return JAVA_1_6; 207 case "1.7": 208 return JAVA_1_7; 209 case "1.8": 210 return JAVA_1_8; 211 case "9": 212 return JAVA_9; 213 case "10": 214 return JAVA_10; 215 case "11": 216 return JAVA_11; 217 case "12": 218 return JAVA_12; 219 case "13": 220 return JAVA_13; 221 case "14": 222 return JAVA_14; 223 case "15": 224 return JAVA_15; 225 case "16": 226 return JAVA_16; 227 case "17": 228 return JAVA_17; 229 case "18": 230 return JAVA_18; 231 case "19": 232 return JAVA_19; 233 case "20": 234 return JAVA_20; 235 case "21": 236 return JAVA_21; 237 default: 238 final float v = toFloatVersion(versionStr); 239 if ((v - 1.) < 1.) { // then we need to check decimals > .9 240 final int firstComma = Math.max(versionStr.indexOf('.'), versionStr.indexOf(',')); 241 final int end = Math.max(versionStr.length(), versionStr.indexOf(',', firstComma)); 242 if (Float.parseFloat(versionStr.substring(firstComma + 1, end)) > .9f) { 243 return JAVA_RECENT; 244 } 245 } else if (v > 10) { 246 return JAVA_RECENT; 247 } 248 return null; 249 } 250 } 251 252 /** 253 * Transforms the given string with a Java version number to the 254 * corresponding constant of this enumeration class. This method is used 255 * internally. 256 * 257 * @param versionStr the Java version as string 258 * @return the corresponding enumeration constant or <b>null</b> if the 259 * version is unknown 260 */ 261 // helper for static importing 262 static JavaVersion getJavaVersion(final String versionStr) { 263 return get(versionStr); 264 } 265 266 /** 267 * Gets the Java Version from the system or 99.0 if the {@code java.specification.version} system property is not set. 268 * 269 * @return the value of {@code java.specification.version} system property or 99.0 if it is not set. 270 */ 271 private static float maxVersion() { 272 final float v = toFloatVersion(System.getProperty("java.specification.version", "99.0")); 273 return v > 0 ? v : 99f; 274 } 275 276 /** 277 * Parses a float value from a String. 278 * 279 * @param value the String to parse. 280 * @return the float value represented by the string or -1 if the given String can not be parsed. 281 */ 282 private static float toFloatVersion(final String value) { 283 final int defaultReturnValue = -1; 284 if (!value.contains(".")) { 285 return NumberUtils.toFloat(value, defaultReturnValue); 286 } 287 final String[] toParse = value.split("\\."); 288 if (toParse.length >= 2) { 289 return NumberUtils.toFloat(toParse[0] + '.' + toParse[1], defaultReturnValue); 290 } 291 return defaultReturnValue; 292 } 293 294 /** 295 * The float value. 296 */ 297 private final float value; 298 299 /** 300 * The standard name. 301 */ 302 private final String name; 303 304 /** 305 * Constructor. 306 * 307 * @param value the float value 308 * @param name the standard name, not null 309 */ 310 JavaVersion(final float value, final String name) { 311 this.value = value; 312 this.name = name; 313 } 314 315 /** 316 * Whether this version of Java is at least the version of Java passed in. 317 * 318 * <p>For example:<br> 319 * {@code myVersion.atLeast(JavaVersion.JAVA_1_4)}</p> 320 * 321 * @param requiredVersion the version to check against, not null 322 * @return true if this version is equal to or greater than the specified version 323 */ 324 public boolean atLeast(final JavaVersion requiredVersion) { 325 return this.value >= requiredVersion.value; 326 } 327 328 /** 329 * Whether this version of Java is at most the version of Java passed in. 330 * 331 * <p>For example:<br> 332 * {@code myVersion.atMost(JavaVersion.JAVA_1_4)}</p> 333 * 334 * @param requiredVersion the version to check against, not null 335 * @return true if this version is equal to or greater than the specified version 336 * @since 3.9 337 */ 338 public boolean atMost(final JavaVersion requiredVersion) { 339 return this.value <= requiredVersion.value; 340 } 341 342 /** 343 * The string value is overridden to return the standard name. 344 * 345 * <p>For example, {@code "1.5"}.</p> 346 * 347 * @return the name, not null 348 */ 349 @Override 350 public String toString() { 351 return name; 352 } 353}