Java：如何创建一个接受第一个元素列表的列表 cons

Question

When I create a Java list and I want that the head is a list, should it print a [[-1,0],1,2,3,4] or its alright it just leave the sublist [-1, 0] as two separated elements like [-1, 0, 1, 2,3,4] and, how can I get the first structure as an aswer.

Answer 1

From your post I guess you are asking about how to create a list "construct" in Java which contains both list and non-list elements.

In Java all elements of your list/array need to have the same type. In the example you posted ( [[-1,0],1,2,3,4] ), the elements are not all the same type. What you have is this: [List<Integer>, Integer, Integer, Integer, Integer] . The first one is different, which isn't allowed in Java.

So, what you need to do is make it so that all elements of your list/array are the same type.

For your case, where there are only integers in your list , the easiest thing to do is to change your types to this: [List<Integer>, List<Integer>, List<Integer>, List<Integer>, List<Integer>] (with your specific values: [[-1,0],[1],[2],[3],[4]] ). Instead of a list of List<Integer> and Integer , you now have a list containing only List<Integer> (some of your lists happen to contain only 1 element, but that is ok).

This is called a "two-dimensional list" and depending on whether you want to code it with arrays or java.util.List s you can code it in one of the following ways:

// with arrays

int[] myTwoDarr = int[5][];
myTwoDarr[0] = new int[]{-1, 0};
myTwoDarr[1] = new int[]{1};
myTwoDarr[2] = new int[]{2};
myTwoDarr[3] = new int[]{3};
myTwoDarr[4] = new int[]{4};

// With Lists

List<List<Integer>> myList = new LinkedList<>();
List<Integer> nestedList1 = new LinkedList<>();
nestedList.add(-1);
nestedList.add(0);
myList.add(nestedList1);
List<Integer> nestedList2 = new LinkedList<>();
nestedList2.add(1);
myList.add(nestedList2);
...etc...

Now, if you absolutely must have different kinds of data in your list, you can create a list of Object instead.

In Java Object is a type from which all non-primitive types inherit. Thus, as long as something is not a primitive, it is an Object and can go in a list of Object . This will allow you to put any kind of data in the elements of your list. Using Object allows you to have a list of all the same type which looks like this: [Object, Object, Object, Object, Object] . But, now Java does not know the specific types you actually have stored in your elements so you will need to type cast when getting them.

Here's an example using a java.util.List :

List<Object> myList = new LinkedList<>();
List<Integer> nestedList = new LinkedList<>();
nestedList.add(-1);
nestedList.add(0);
myList.add(nestedList);
myList.add(1);
myList.add("a string");

// You need to cast when taking elements out of the list.
List<Integer> newNest = (List<Integer>) myList.get(0);
Integer myInt = (Integer) myList.get(1);
String myString = (String) myList.get(2);

Since all your base data types are the same ( Integer / int ) I recommend avoiding the Object list method and going with the 2D list. It's simpler and less error prone to not do all this casting.