An ArrayList behaves more like a List than like an array and thus, you cannot insert element at random indexes that don't previously exist. What you classify as a flaw is a deliberate, conscious design decision. If you need a data structure where you can insert elements at random positions, you need an array. Period.

It appears than the option --list doesn't take arguments, it's a bug in the manual synopsis.Moreover for manage my java versions I should try env variables.

(The bug has been reported as https://github.com/fedora-sysv/chkconfig/issues/11)

Just bear in mind the following difference:

• List.of was introduced with Java 9, and it returns an unmodifiable List. The list returned by the method cannot be resized nor modified, which means, you cannot add, remove or replace any element either on the list or its iterator.
• Arrays.asList: This returns instead a not resizable List, which means that you can replace an element of the list but cannot remove or add any element.

With Java 8, the best option to get the same thing as List.of is to use the static method Collections.unmodifiableList. You can use it just to wrap your list, so every time you try to do any operation on the list or on its iterator (i.e. set, add, remove) an UnsupportedOperationException is thrown. Here is an example related to a List of String.

List<String> newUnmodList = Collections.unmodifiableList(oldList);

Confusing error messages: Clojure's error messages more often than not are very confusing. They usually involve stack traces that do not thoroughly explain where the error was caused or what caused it. | Immutability is the default: Clojure programmers are highly encouraged to use immutable data in their code. Therefore, most data will be immutable by default. · State change is handled by functions (for transformations) and atoms (an abstraction that encapsulates the idea of some entity having an identity). | Minimal syntax: Being a LISP, programs are simple: they're just functions and data. That it doesn't get bogged down with syntax or the loftier FP concepts like monads makes it one of most approachable functional languages for beginners. | Tries to solve problems as simply as possible: Simplicity is one of the pillars on which Clojure is built. Clojure tries to solve many problems in software development as simply as possible. Instead of building complex interfaces, objects or factories, it uses immutability and simple data structures. | Good for writing concurrent programs: Since Clojure is designed for concurrency, it offers things like Software Transaction Memory, functional programming without side-effects and immutable data structures right out of the box. This means that the development team can focus their energies on developing features instead of concurrency details. | Huge ecosystem of libraries to work with: There's a very large ecosystem of high-quality Clojure libraries which developers can use. One example is Incanter. It's a great data analytics library and a very powerful tool for dealing with matrices, datasets and csv files. | Code tends to be nightmare to maintain for non-authors: Tendency to devolve into difficult to manage mess of styles. Not recommended for professional use. | Too cult-ish: Way too niche and in-group behavior, while trying to trash other languages. Only pays for select few, who run the "game" on others. | Cross platform: Clojure compiles to JVM bytecode and runs inside the JVM. This means that applications written in Clojure are cross-platform out of the box. | Rich Hickey: The creator is so awesome, he's a feature. Just look up his talks and see why. | Dynamic language: A superb data processing language. While rich type and specification systems are available they are optional. | Tied to the JVM and it's limitations: Some language constructs were obviously created as workarounds for JVM limitations. This makes the language much less elegant than it could have been. · Also, the JVM has a very cumbersome FFI. | Syntax can be alien / jarring for those used to other Lisps: Perhaps some may consider this attribute an advantage, but I do not. Clojure does not attempt to maintain significant compatibility with other Lisps. So, if you already know a Lisp or are used to the way Lisp works in general, you'll probably be confused if you take a look at Clojure. See these resources for more details on this subject: · - https://clojure.org/reference/lisps · - http://stackoverflow.com/q/6008313/2636454 · - http://gilesbowkett.blogspot.com/2015/01/one-major-difference-between-clojure.html · - http://softwareengineering.stackexchange.com/q/153128/166211 | Extensible: Clojure has an elegant macro system which enables language additions, Domain-specific languages (DSLs), to be created much easier than most other languages (with the exception of Racket, perhaps). | Great tool used in automating, configuring and managing dependencies available: Leiningen is a very useful tool for Clojure developers. It helps wiht automation, configuration and dependency management. It's basically a must for every Clojure project. | No C/Java syntax: Refreshing, BTW! | Game is available with which you can learn Clojure: Nightmod is a tool used to make "live-moddable" games. It displays the game's code while you are playing and allows you to inject new code using Clojure. This can be a fun and useful experience for people trying to learn Clojure. | Dynamic types: You can put anything in. This makes reasoning about code after a time has passed very hard.

If you know that you won't need to add anything to the list later, you can just do

List<Double> myList = Arrays.asList(3.01d, 4.02d, 5.03d);

I'm pretty sure the list returned from Arrays.asList can be modified, but only in that you can change the elements that are there -- you can't add new elements to it.

I assume that your worksheets contain tabular data, i.e., the first row contains field names and the following rows contain values. In such a case it would make sense to define a Table class whose instances would each contain the contents of one worksheet. This Table object could hold general information regarding one worksheet, if necessary, like the name of the worksheet tab.

It could also have a list holding the column names or a dictionary holding the column indexes with the column names as a key. If you define a Column class for this purpose (instead of just a string for the column name), it allows you to store additional information regarding a column, like its type (numeric, text, date) and display format.

Even if you don't need this kind of infrastructure right now, having such classes allows you to add this kind of functionality much easier later.

The Table class would also contain a list of rows. Here again, having a Row class can have advantages. However, it would be ok to represent one row as an array of strings, for instance. Since each row of the table has the same length, a list is not necessary here.

Instead of using strings to store the values, having a Value class or struct can also have advantages. Such a type could automatically convert strings to an appropriate type, could perform comparisons between values of the same type etc.

Without knowing more about your data and the kind of logic you want to apply to it, it is difficult to give you an answer tailored to fit your needs.

If each of your objects has only these two attributes (name and otherAttr), you could create a class with fields instead of using Map:

public class Data {
    private final String name;
    private final String otherAttr;
    // constructor, getters
}

It may be useful to do so even if you have more attributes, because it gives you compile-time safety - you will never misspell a key. You can also have fields of different types, not just Strings that you would have to parse.

To make your code more meaningful you can also extend existing data structures, e.g.:

public class Data extends HashMap<String, String> {
    // extra convenience constructors
}

public class DataList extends ArrayList<Data> {
    // extra convenience constructors
}

In regards to your question what collections to use, it really depends on what you need. ArrayList is usually a good choice (or thread-safe Vector), unless you frequently modify the beginning of the list in which case LinkedList would be recommended. HashMap has very good performance, but if you need sorted data you could use TreeMap instead. If you need to maintain order of insertion LinkedHashMap will be the best.

Confusing error messages: Clojure's error messages more often than not are very confusing. They usually involve stack traces that do not thoroughly explain where the error was caused or what caused it. | Immutability is the default: Clojure programmers are highly encouraged to use immutable data in their code. Therefore, most data will be immutable by default. · State change is handled by functions (for transformations) and atoms (an abstraction that encapsulates the idea of some entity having an identity). | Minimal syntax: Being a LISP, programs are simple: they're just functions and data. That it doesn't get bogged down with syntax or the loftier FP concepts like monads makes it one of most approachable functional languages for beginners. | Tries to solve problems as simply as possible: Simplicity is one of the pillars on which Clojure is built. Clojure tries to solve many problems in software development as simply as possible. Instead of building complex interfaces, objects or factories, it uses immutability and simple data structures. | Good for writing concurrent programs: Since Clojure is designed for concurrency, it offers things like Software Transaction Memory, functional programming without side-effects and immutable data structures right out of the box. This means that the development team can focus their energies on developing features instead of concurrency details. | Huge ecosystem of libraries to work with: There's a very large ecosystem of high-quality Clojure libraries which developers can use. One example is Incanter. It's a great data analytics library and a very powerful tool for dealing with matrices, datasets and csv files. | Code tends to be nightmare to maintain for non-authors: Tendency to devolve into difficult to manage mess of styles. Not recommended for professional use. | Too cult-ish: Way too niche and in-group behavior, while trying to trash other languages. Only pays for select few, who run the "game" on others. | Cross platform: Clojure compiles to JVM bytecode and runs inside the JVM. This means that applications written in Clojure are cross-platform out of the box. | Rich Hickey: The creator is so awesome, he's a feature. Just look up his talks and see why. | Dynamic language: A superb data processing language. While rich type and specification systems are available they are optional. | Tied to the JVM and it's limitations: Some language constructs were obviously created as workarounds for JVM limitations. This makes the language much less elegant than it could have been. · Also, the JVM has a very cumbersome FFI. | Syntax can be alien / jarring for those used to other Lisps: Perhaps some may consider this attribute an advantage, but I do not. Clojure does not attempt to maintain significant compatibility with other Lisps. So, if you already know a Lisp or are used to the way Lisp works in general, you'll probably be confused if you take a look at Clojure. See these resources for more details on this subject: · - https://clojure.org/reference/lisps · - http://stackoverflow.com/q/6008313/2636454 · - http://gilesbowkett.blogspot.com/2015/01/one-major-difference-between-clojure.html · - http://softwareengineering.stackexchange.com/q/153128/166211 | Extensible: Clojure has an elegant macro system which enables language additions, Domain-specific languages (DSLs), to be created much easier than most other languages (with the exception of Racket, perhaps). | Great tool used in automating, configuring and managing dependencies available: Leiningen is a very useful tool for Clojure developers. It helps wiht automation, configuration and dependency management. It's basically a must for every Clojure project. | No C/Java syntax: Refreshing, BTW! | Game is available with which you can learn Clojure: Nightmod is a tool used to make "live-moddable" games. It displays the game's code while you are playing and allows you to inject new code using Clojure. This can be a fun and useful experience for people trying to learn Clojure. | Dynamic types: You can put anything in. This makes reasoning about code after a time has passed very hard.