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 * <p>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. </p> 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 * The most recent java version. Mainly introduced to avoid to break when a new version of Java is used. 148 */ 149 JAVA_RECENT(maxVersion(), Float.toString(maxVersion())); 150 151 /** 152 * The float value. 153 */ 154 private final float value; 155 156 /** 157 * The standard name. 158 */ 159 private final String name; 160 161 /** 162 * Constructor. 163 * 164 * @param value the float value 165 * @param name the standard name, not null 166 */ 167 JavaVersion(final float value, final String name) { 168 this.value = value; 169 this.name = name; 170 } 171 172 //----------------------------------------------------------------------- 173 /** 174 * <p>Whether this version of Java is at least the version of Java passed in.</p> 175 * 176 * <p>For example:<br> 177 * {@code myVersion.atLeast(JavaVersion.JAVA_1_4)}<p> 178 * 179 * @param requiredVersion the version to check against, not null 180 * @return true if this version is equal to or greater than the specified version 181 */ 182 public boolean atLeast(final JavaVersion requiredVersion) { 183 return this.value >= requiredVersion.value; 184 } 185 186 //----------------------------------------------------------------------- 187 /** 188 * <p>Whether this version of Java is at most the version of Java passed in.</p> 189 * 190 * <p>For example:<br> 191 * {@code myVersion.atMost(JavaVersion.JAVA_1_4)}<p> 192 * 193 * @param requiredVersion the version to check against, not null 194 * @return true if this version is equal to or greater than the specified version 195 * @since 3.9 196 */ 197 public boolean atMost(final JavaVersion requiredVersion) { 198 return this.value <= requiredVersion.value; 199 } 200 201 /** 202 * Transforms the given string with a Java version number to the 203 * corresponding constant of this enumeration class. This method is used 204 * internally. 205 * 206 * @param nom the Java version as string 207 * @return the corresponding enumeration constant or <b>null</b> if the 208 * version is unknown 209 */ 210 // helper for static importing 211 static JavaVersion getJavaVersion(final String nom) { 212 return get(nom); 213 } 214 215 /** 216 * Transforms the given string with a Java version number to the 217 * corresponding constant of this enumeration class. This method is used 218 * internally. 219 * 220 * @param versionStr the Java version as string 221 * @return the corresponding enumeration constant or <b>null</b> if the 222 * version is unknown 223 */ 224 static JavaVersion get(final String versionStr) { 225 if (versionStr == null) { 226 return null; 227 } 228 switch (versionStr) { 229 case "0.9": 230 return JAVA_0_9; 231 case "1.1": 232 return JAVA_1_1; 233 case "1.2": 234 return JAVA_1_2; 235 case "1.3": 236 return JAVA_1_3; 237 case "1.4": 238 return JAVA_1_4; 239 case "1.5": 240 return JAVA_1_5; 241 case "1.6": 242 return JAVA_1_6; 243 case "1.7": 244 return JAVA_1_7; 245 case "1.8": 246 return JAVA_1_8; 247 case "9": 248 return JAVA_9; 249 case "10": 250 return JAVA_10; 251 case "11": 252 return JAVA_11; 253 case "12": 254 return JAVA_12; 255 case "13": 256 return JAVA_13; 257 case "14": 258 return JAVA_14; 259 case "15": 260 return JAVA_15; 261 case "16": 262 return JAVA_16; 263 case "17": 264 return JAVA_17; 265 default: 266 final float v = toFloatVersion(versionStr); 267 if ((v - 1.) < 1.) { // then we need to check decimals > .9 268 final int firstComma = Math.max(versionStr.indexOf('.'), versionStr.indexOf(',')); 269 final int end = Math.max(versionStr.length(), versionStr.indexOf(',', firstComma)); 270 if (Float.parseFloat(versionStr.substring(firstComma + 1, end)) > .9f) { 271 return JAVA_RECENT; 272 } 273 } else if (v > 10) { 274 return JAVA_RECENT; 275 } 276 return null; 277 } 278 } 279 280 //----------------------------------------------------------------------- 281 /** 282 * <p>The string value is overridden to return the standard name.</p> 283 * 284 * <p>For example, {@code "1.5"}.</p> 285 * 286 * @return the name, not null 287 */ 288 @Override 289 public String toString() { 290 return name; 291 } 292 293 /** 294 * Gets the Java Version from the system or 99.0 if the {@code java.specification.version} system property is not set. 295 * 296 * @return the value of {@code java.specification.version} system property or 99.0 if it is not set. 297 */ 298 private static float maxVersion() { 299 final float v = toFloatVersion(System.getProperty("java.specification.version", "99.0")); 300 if (v > 0) { 301 return v; 302 } 303 return 99f; 304 } 305 306 /** 307 * Parses a float value from a String. 308 * 309 * @param value the String to parse. 310 * @return the float value represented by the string or -1 if the given String can not be parsed. 311 */ 312 private static float toFloatVersion(final String value) { 313 final int defaultReturnValue = -1; 314 if (value.contains(".")) { 315 final String[] toParse = value.split("\\."); 316 if (toParse.length >= 2) { 317 return NumberUtils.toFloat(toParse[0] + '.' + toParse[1], defaultReturnValue); 318 } 319 } else { 320 return NumberUtils.toFloat(value, defaultReturnValue); 321 } 322 return defaultReturnValue; 323 } 324}