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 8 years ago.
Improve this question
Basically, when I try to remove an element from an ArrayList by someList.remove(someInteger); it does nothing, the element at that index stays there and the list is unchanged. I'm using java SE's ArrayList implementation. It is ensured that the list has an element at the given index. The boolean returned from the method is false.
There are two methods called remove(), and you're accidentally calling the wrong one.
The boolean returned from the method is false.
If the method is returning a boolean, then it's this overload:
boolean remove(Object o)
and not that one:
E remove(int index)
In other words, it's trying to remove the object by value and not by index (presumably from an ArrayList<Integer> or similar).
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 3 years ago.
Improve this question
I may I not search enought but I haven't find any answer.
[[Collection]<T>][1] have an T get() methode, an void add(T t) method, and an void addAll(Collection<? extends T> c) method.
Then why we dont have an Collection<? extends T> getAll(Predicate<? extends T> p) method?
I know taht it souldn't be hard to make a subclass who implements it. But I dont understand why it is not already their.
Late edit:
Here a concrete exemple for sceptical.
I have to code :
wellsDisplayers = new ArrayList<DisplayWell>(Arrays.asList(displayerList.stream().filter(x->DisplayWell.class.isInstance(x)).toArray(DisplayWell[]::new)));
instead of :
wellsDisplayers = displayerList.getAll(x->DisplayWell.class.isInstance(x));
But you are right stream methode is really easy to use and understand, just like how java sould be.
I think you misunderstood the concept of a Collection. There is no getAll() method since you already have every element. Simply use the stream().filter() syntax and collect or map to do whatever e.g.
collection.stream().filter(x -> x..) // do stuff
I think you're looking for Collection.removeIf(Predicate<? super E> filter), although you'll need to negate the predicate logic. Alternately, you can use streams: collection.stream().filter(p).
As for why there isn't a getAll to go along with the other methods, I don't see where the Predicate parameter is coming from, you're not getting "all" if you filter some out. The addAll method adds all the elements, so the analagous method getAll would get all the elements, which is just the collection itself, so it would be redundant.
Also, Collection doesn't even have a get() method in the first place. Maybe you're thinking of List.get(int). I suppose you could have an "All" version like getAll(int[]) that returns the elements at all the given indexes, but that doesn't seem very useful when subList(int, int) already exists.
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 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 8 years ago.
Improve this question
If I declare a new list like this:
List<String> listExample = someFunction();
what list interface implementation will be used?
EDIT: Thanks for the answers so far. What is considered as the clean way to do this, should I always declare list with new?
As Eran commented that totally depends on what someFunction(); returns .Both ArrayList<E> and LinkedList implements List interface .
You can try ,
System.out.println("" + listExample.getClass());
to find out the which has been implemented. From docs,
public final Class<?> getClass()
Returns the runtime class of this Object. The returned Class object is
the object that is locked by static synchronized methods of the
represented class.
Whatever you are building e.g. LinkedList, ArrayList, Vector, Stack in and returning from someFunction() will be implemented with listexample. If you are using List interface reference, it has one benefit, that you can assign any type of object to it (LinkedList, ArrayList, Vector, Stack).
eg if u give
List listExample = new ArrayList();
Then the Object will be created for ArrayList and list is just an instance of listExample.
and you can use getClass() for that listExample to view
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking for code must demonstrate a minimal understanding of the problem being solved. Include attempted solutions, why they didn't work, and the expected results. See also: Stack Overflow question checklist
Closed 9 years ago.
Improve this question
I have a varargs method in java. So, the method expects an array of Objects. I passed a List to the method and it worked! I mean, it not only compiled, but the tests were green. So, my question is - do I have to call myList.toArray() when calling the method, or does this call happen automatically?
Thanks in advance!
And here is the code:
createSomething(final Object... parameters) {
// varargs method
}
List<Object> data = new ArrayList<Object>();
createSomething(data); // is this wrong?
createSomething(data.toArray()); // should I always do this?
You seem to think that the list was implicitely transformed to an array, and that the method was invoked with an array containing each element of the list.
That's not the case. In fact, the method was invoked with an array containing a single element: the list itself.
Test it with
private void testVarargs(Object... args) {
System.out.println(args.length);
System.out.println(args[0]);
}
and
List<String> list = Arrays.asList("hello", "world");
testVarargs(list);
The result won't be
2
hello
but
1
[hello, world]
And that's normal: you just passed a single object as argument to the method, which happens to be a List. The List is thus enclosed inside a one-length array and the method is called with that array as argument.