How would you create an array list with mixed booleans and chars? [closed]

Answer 1

Here are a few facts for you:

• You can't put primitive values in a Collection (generic types can only bind to reference types)

• If you necessarily need to put both chars and doubles (or Charactersand Doubles taking the above point into consideration) you need to declare the list to contain the least common subtype of Character and Double which is Object:

  List<Object> charsAndDoubles = new ArrayList<Object>();
  

  this will however not disallow Strings and Integers.

• Here's how I would solve it:

  class MyDatatype {
      ....
  }
  
  class MyDatatypeCharVariant extends MyDatatype {
      char data;
  
      ...
  }
  
  class MyDatatypeDoubleVariant extends MyDatatype {
      double data;
  
      ...
  }
  

  and then declare the list as:

  List<MyDatatype> someList = new ArrayList<MyDatatype>();
  

Answer 2

How would you create an array list with booleans and chars, not strings or integers?

You can't do it using static typing. The Java type system doesn't allow it.

The best you could do is to implement a List<Object> class that checks the type of the elements that it is puting into the list. (You could extend ArrayList<Object> and override the methods that add or modify list elements.)

---

Tom's answer is another way to achieve this, at the cost of an extra wrapper object for each list element. This avoids the need for a typecast on extraction, but you could do that by adding getInt(pos) and getChar(pos) methods to the custom list class.

Answer 3

You can't mix types in an Arraylist. If you need different types in it you have to use the common type Object.

ArrayList<Object> DCList = new ArrayList<Object>();

And you can't use primitive types in an Arraylist like int or double. Use Integer and Double.

Answer 4

As Mitch says, that syntax won't work you could possibly create a generic type called an Either, something I've used a few times in the past.

class Either<LEFT,RIGHT> {
    LEFT left;
    RIGHT right;
    public Either(LEFT left, RIGHT right) {
        if (left != null && right != null) {
            throw new IllegalStateException();
        }
    }
    public LEFT getLeft() {
        return left;
    }
    public boolean isLeft() {
        return left != null;
    }
    public RIGHT getRight() {
        return right;
    }
    public boolean isRight() {
        return right != null;
    }
}

List<Either<Double,Char>> list = new ArrayList<Either<Double,Char>>();

It's pretty rare that this is the right approach though.

Answer 5

public class Pair<T1, T2> {
  ...
}

ArrayList<Pair<Double, Character>> DCList = new ArrayList<Pair<Double, Character>>();

I'll leave the implementation of the Pair class to you.

In many cases you probably have classes that describe the things you want to store, i.e.

public class FooItem {
  private double doubleThing;
  private char charThing;
  public double getDoubleThing() { return doubleThing; }
  public char getCharThing() { return charThing; }
  ...
}

and then just use

ArrayList<FooItem>