View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.lang3;
18  
19  import org.apache.commons.lang3.math.NumberUtils;
20  
21  /**
22   * An enum representing all the versions of the Java specification.
23   * This is intended to mirror available values from the
24   * <em>java.specification.version</em> System property.
25   *
26   * @since 3.0
27   */
28  public enum JavaVersion {
29  
30      /**
31       * The Java version reported by Android. This is not an official Java version number.
32       */
33      JAVA_0_9(1.5f, "0.9"),
34  
35      /**
36       * Java 1.1.
37       */
38      JAVA_1_1(1.1f, "1.1"),
39  
40      /**
41       * Java 1.2.
42       */
43      JAVA_1_2(1.2f, "1.2"),
44  
45      /**
46       * Java 1.3.
47       */
48      JAVA_1_3(1.3f, "1.3"),
49  
50      /**
51       * Java 1.4.
52       */
53      JAVA_1_4(1.4f, "1.4"),
54  
55      /**
56       * Java 1.5.
57       */
58      JAVA_1_5(1.5f, "1.5"),
59  
60      /**
61       * Java 1.6.
62       */
63      JAVA_1_6(1.6f, "1.6"),
64  
65      /**
66       * Java 1.7.
67       */
68      JAVA_1_7(1.7f, "1.7"),
69  
70      /**
71       * Java 1.8.
72       */
73      JAVA_1_8(1.8f, "1.8"),
74  
75      /**
76       * Java 1.9.
77       *
78       * @deprecated As of release 3.5, replaced by {@link #JAVA_9}
79       */
80      @Deprecated
81      JAVA_1_9(9.0f, "9"),
82  
83      /**
84       * Java 9.
85       *
86       * @since 3.5
87       */
88      JAVA_9(9.0f, "9"),
89  
90      /**
91       * Java 10.
92       *
93       * @since 3.7
94       */
95      JAVA_10(10.0f, "10"),
96  
97      /**
98       * Java 11.
99       *
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 }