Kan iemand me alsjeblieft uitleggen waarom ik niet List<>Naar ArrayList<>met de eerste benadering en ik doen met de tweede? Bedankt.
Eerste aanpak:
ArrayList<Task> tmp = ((ArrayList<Task>)mTrackytAdapter.getAllTasks(token));
Tweede aanpak:
ArrayList<Task> tmp = new ArrayList<Task>(mTrackytAdapter.getAllTasks(token));
Antwoord 1, Autoriteit 100%
Wanneer u de tweede doet, maakt u een nieuwe arrayclist, u probeert niet te doen alsof de andere lijst een arrayclist is.
Ik bedoel, wat als de originele lijst wordt geïmplementeerd als een Linkedlist of een aangepaste lijst? Je zult het niet weten. De tweede aanpak heeft de voorkeur als u echt een arrayclist van het resultaat wilt maken. Maar je kunt het gewoon als een lijst laten, dat is een van de beste voordelen van het gebruik van interfaces!
Antwoord 2, Autoriteit 51%
Wanneer u tweede aanpak gebruikt, initialiseert u Arrayclist met zijn vooraf gedefinieerde waarden.
Zoals over het algemeen doen we
ArrayList ListOfstrings = Nieuwe ArrayList & LT; & GT; ();
Laten we zeggen dat je een array met waarden hebt, nu wil je deze array omzetten in Arraypagina.
U moet eerst de lijst van de array ophalen met behulp van arrays euils.
Omdat de ArrayList betontype is die een lijstinterface implementeert. Het is niet gegarandeerd dat methode ASLIST, dit type implementatie retourneert.
List<String> listofOptions = (List<String>) Arrays.asList(options);
Dan kunt u gebruiker constructoru van een arrayclist om te instantiëren met vooraf gedefinieerde waarden.
ArrayList<String> arrlistofOptions = new ArrayList<String>(list);
Dus je tweede benadering is dat je waarden hebt doorgegeven die arraylist zullen combineren met de lijstelementen.
Meer over
ArrayList die wordt geretourneerd door Arrays.asList is geen echte arraylist, het is gewoon een wrapper die geen enkele wijziging in de lijst toestaat.
Als je probeert toe te voegen of te verwijderen via Arrays.asList, krijg je
UnsupportedOperationException
Antwoord 3, autoriteit 16%
Probeer de volgende code uit te voeren:
List<String> listOfString = Arrays.asList("Hello", "World");
ArrayList<String> arrayListOfString = new ArrayList(listOfString);
System.out.println(listOfString.getClass());
System.out.println(arrayListOfString.getClass());
Je krijgt het volgende resultaat:
class java.util.Arrays$ArrayList
class java.util.ArrayList
Dus dat betekent dat het 2 verschillende klassen zijn die elkaar niet uitbreiden. java.util.Arrays$ArrayList betekent de privéklasse met de naam ArrayList (binnenste klasse van de klasse Arrays) en java.util.ArrayList betekent de openbare klasse met de naam ArrayList. Casten van java.util.Arrays$ArrayList naar java.util.ArrayList en vice versa is dus niet relevant/niet beschikbaar.
Antwoord 4, autoriteit 14%
De tweede benadering is duidelijk verkeerd als je wilt casten. Het maakt een nieuwe ArrayList aan.
De eerste benadering zou echter prima moeten werken, als en alleen als getAllTasks een ArrayList retourneert.
Is het echt nodig dat je een ArrayList hebt? is de lijst-interface niet genoeg? Wat u doet, kan leiden tot Runtime Exception als het type niet correct is.
Als getAllTasks() een ArrayList retourneert, moet je het retourtype in de klassedefinitie wijzigen en dan heb je geen cast nodig en als het iets anders retourneert, kun je niet casten naar ArrayList.
Antwoord 5, autoriteit 14%
Probeer dit eens:
ArrayList<SomeClass> arrayList;
public SomeConstructor(List<SomeClass> listData) {
arrayList.addAll(listData);
}
Antwoord 6, autoriteit 8%
Je kunt List<> casten. naar ArrayList<> als je begrijpt wat je doet. Java-compiler blokkeert het niet.
Maar:
- Het is een slechte gewoonte om het bovenliggende type naar het onderliggende type (of de interface naar het implementatietype) te casten zonder te controleren.
Op deze manier beter:
if (list instanceof ArrayList<Task>) {
ArrayList<Task> arraylist = (ArrayList<Task>) list;
}
- Misschien heb je geen implementatietype nodig als referentie. Kijk SonarQube-waarschuwing https://sbforge.org/sonar/rules/show/squid:S1319. Je kunt deze casting in de meeste gevallen vermijden.
- Je kunt de Guava-methode gebruiken:
ArrayList<Task> arraylist = Lists.newArrayList(list);
Antwoord 7, autoriteit 5%
De eerste benadering is proberen de lijst te casten, maar dit zou alleen werken als de List<>een ArrayList<>was. Dat is niet het geval. U hebt dus de tweede benadering nodig, namelijk het bouwen van een nieuwe ArrayList<>met de elementen van de List<>
Antwoord 8, autoriteit 3%
Omdat je in de eerste een verzameling probeert te converteren naar een ArrayList.
In de 2e gebruik je gewoon de ingebouwde constructor van ArrayList
Antwoord 9, autoriteit 3%
Mogelijk:
ArrayList<ServiceModel> services = new ArrayList<>(parking.getServices());
intent.putExtra("servicios",services);
Antwoord 10
import java.util.List;
import java.util.Arrays;
import java.util.*;
public class Merge
{
public static void main(String[] args) {
// This is normal way
// List<Integer> l1 = new ArrayList<Integer>(); l1.add(2); l1.add(5); l1.add(10); l1.add(22);
// List<Integer> l2 = new ArrayList<Integer>(); l2.add(3); l2.add(8); l2.add(15);
//Array.asList only have the list interface, but ArrayList is inherited from List Interface with few more property like ArrayList.remove()
List<Integer> templ1 = Arrays.asList(2,5,10,22);
List<Integer> templ2 = Arrays.asList(3,8,12);
//So creation of ArrayList with the given list is required, then only ArrayList.remove function works.
List<Integer> l1 = new ArrayList<Integer>(templ1);
List<Integer> l2 = new ArrayList<Integer>(templ2);
List<Integer> l3 = new ArrayList<Integer>();
Iterator itr1 = l1.iterator();
while(itr1.hasNext()){
int x = (Integer) itr1.next();
Iterator itr2 = l2.iterator();
while(itr2.hasNext()) {
int y = (Integer) itr2.next();
if(x < y) {
l3.add(x);
break;
}
else{
l3.add(y);
itr2.remove();
}
}
}
Iterator it = l1.iterator();
while (it.hasNext()){
int k = (Integer) it.next();
if (l3.contains(k)){
continue;
}
else{
l3.add(k);
System.out.println(k);
}
}
Iterator itr2 = l2.iterator();
while (itr2.hasNext()){
int k = (Integer) itr2.next();
l3.add(k);
}
System.out.println(l3);
}
}