Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 2 years ago.
Improve this question
Let's say I have
ArrayList<Citizen> citizen1 = new ArrayList<Citizen>();
ArrayList<Citizen> citizen2 = new ArrayList<Citizen>();
ArrayList<Citizen> citizen3 = new ArrayList<Citizen>();
is it possible to have an arraylist which compromise them all?
List<List<Citizen>> mainList= new ArrayList<>();
You can go with List of List.
Also need to consider below points.
I recommend using "List" instead of "ArrayList" on the left side when creating list objects. It's better to pass around the interface "List" because then if later you need to change to using something like Vector (e.g. you now need synchronized lists), you only need to change the line with the "new" statement. No matter what implementation of list you use, e.g. Vector or ArrayList, you still always just pass around List.
In the ArrayList constructor, you can leave the list empty and it will default to a certain size and then grow dynamically as needed. But if you know how big your list might be, you can sometimes save some performance. For instance, if you knew there were always going to be 500 lines in your file, then you could do:
You can have a List of Lists of Citizen, like this: List<List<Citizen>>= new ArrayList<>();
You can use the addAll() methods of List and Collection to add to one List all the elements of another list.
If using at least Java 8, you can do various things using the Streams API: Stream.of(), Stream.concat(), and maybe others.
Related
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 1 year ago.
Improve this question
I came across this code. I was wondering if this is possible. As you can see, aList is an ArrayList which .adds() itself.
ArrayList<Object> aList;
aList = new ArrayList<Object>();
aList.add("cat");
aList.add(aList);
aList.add(12);
int size = 0;
Iterator<Object> it = aList.iterator();
while(it.hasNext()) {
it.next();
size++;
}
System.out.print(size);
Yes, it is possible. There are no restrictions on the elements you can add to a ArrayList<Object>.
And you can iterate the list, and do various other things with it.
But don't call toString() on it because you might get a StackOverflowError.
UPDATE - For (at least) Oracle / OpenJDK Java 6 and onwards, the toString() method inherited from AbstractCollection will detect this "self reference" cycle and show it as (this collection) rather than going into an infinite recursive loop.
However:
This is an implementation detail. It is not part of the specification.
I don't know if this applies for all Java versions; i.e. prior to Java 6, and Android versions.
This doesn't apply for 3rd-party List classes that don't extend AbstractCollection. (For them, you would need to check the implementation code to understand what would happen.)
It doesn't apply if the self-reference cycle has more than one "hop"; e.g. list A contains list B, and list B contains list A. In such cases you would get infinite recursion and a StackOverflowError.
So caution is advised.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
To my understanding, a List is an ordered collection of items. And a Set is a collection of unique items.
Now my question is, why does LinkedHashSet, which describes an ordered collection of unique items, implement the Set interface (=> unique), but not the List interface (=> ordered)?
One possible argument is that List is intended for random access datastructures, but that would be invalidated by the fact that LinkedList doesn't have "true" random access either. In fact, LinkedHashSet is backed by an internal linked list. Also the documentation for List says otherwise:
Note that these [positional index] operations may execute in time proportional to the index value for some implementations.
If it implemented a List you would be able to use it as a List:
List list = new LinkedHashSet();
This might lead to issues with duplicates which don't appear in Set but are allowed in List.
In other words, you shouldn't declare that something is a List when it doesn't allow duplicates even if it holds the order and allows adding, getting, removing and checking the size.
Unlike sets, lists typically allow duplicate elements
--List documentation
because LinkHashSet is class which implements set interface . List and Set has its own functionality List allowed duplicates while set do not allowed duplicates but if you want linear order insertion in a HastSet then LinkedHashSet is used with no duplicates in itself ..
Set s = new LinkedHashSet();
is the implementation of a set in which insertion order is preserved and duplicates do not allowed..
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 6 years ago.
Improve this question
In this example http://www.vogella.com/tutorials/JavaPersistenceAPI/article.html#jpaintro_entitymanager if an entity have a #OneToMany relationship. the List is initialized in the declaration like this:
#OneToMany(mappedBy = "family")
private final List<Person> members = new ArrayList<Person>();
I used to not initialize entities lists in my code, and always have to check if null. So My Question is: Is initializing lists (relationships) as an empty list in the declaration is what needs to be done normally or what ? and Why ?
What I'm currently doning
private final List<Person> members
In general "null" and "empty" have different meanings even if the behavior for jpa remains the same. Null means it was never initialized while empty means there are no entries. So if you need to handle those 2 cases different, you can do, if not it doesnt matter which way you go. For example null can mean, that you never load the data you need and you can load it after checking for null. While "empty" means you already load the data but there are no entries
You should ideally decide based on your application logic whether to keep this list as empty or null.
One disadvantage with null is that in the places where you are not expecting this list as null, you have to add extra null checks in the application code.
One better way is to initialize your list using Collections. EMPTY_LIST.
Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 6 years ago.
Improve this question
Now, I have encountered this problem:
I have a non-empty array list declared as original. Then I do this :
ArrayList<ArrayList<Integer>> temp = (ArrayList<ArrayList<Integer>>) original.clone();
temp.get(0).set(1,-1) ;
but the result was that unexpectedly the element at index 1 in both lists were changed.
How can I fix this problem ?
clone makes a shallow copy of the ArrayList. Either make it's Deep Copy since the ArrayList is object type so it can also make new object of it's reference.
You have to deep copy, you can try below code
for(int element:original)
{
temp.add(element);
}
clone makes a shallow copy of the ArrayList. In a sense, this means affecting the ArrayList from one reference also affects the other reference.
Instead, use new ArrayList(original).
Edit: My mistake. You'd have to go through the contents of your ArrayList and clone each object inside. Unfortunately for you, you have ArrayLists inside your ArrayList, so you'd have to do a lot of iterating if you want distinct Integers.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
I want to know whats the difference between creating an object[] objects and List<object> objects?
For example lets say I have a class for a book and i wanted to create an object array of books what would the best approach be?
Simply they are two differenct structures.
Object[] obj = new Object[4]; // Creates an array of 4 Object
List<Object> obj = new ArrayList<Object>(); // Creates a list
// (ArrayList in this case) of Object
An array is a structure that can't change its size.
A list can change it.
A list has many different implementations:
ArrayList
LinkedList
Vector
other implementations also custom implementations
An array is a predefined data structure that can't be changed.
A list has many predefined functions not present in an array.
With a list, you do not have to give a specific number of Items, and you can add whenever you want.
If you know exactly how many book instances you need, you can go for an array. But I prefer to use Lists, since it's more comfortable (imo)