Hoe om te initialiseren List & lt; String & gt; object in Java?

Ik kan niet initialiseren een lijst zoals in de volgende code:

List<String> supplierNames = new List<String>();
supplierNames.add("sup1");
supplierNames.add("sup2");
supplierNames.add("sup3");
System.out.println(supplierNames.get(1));

ik geconfronteerd met de volgende foutmelding:

Kan niet een instantie van het type List<String>

Hoe kan ik instantiëren List<String>

Antwoord 1, Autoriteit 100%

Indien u de API voor Listje zult merken het zegt:

Interface List<E>

Omdat het een interfacebetekent dat het kan niet worden geïnstantieerd (geen new List()is mogelijk).

Als u die verwijzen controleren, vindt u een aantal classvinden es dat de uitvoering van List

Alle bekende implementeren Classes:

AbstractListAbstractSequentialListArrayListAttributeListCopyOnWriteArrayListLinkedList, RoleList, RoleUnresolvedList, Stack, Vector

Deze kunnen worden geconcretiseerd. Gebruik de links om meer te weten over hen, I.E:. Om te weten welke past beter bij uw behoeften

De 3 meest gebruikte die waarschijnlijk zijn:

List<String> supplierNames1 = new ArrayList<String>();
 List<String> supplierNames2 = new LinkedList<String>();
 List<String> supplierNames3 = new Vector<String>();

Bonus:
U kunt het ook op een eenvoudigere manier instantiëren met waarden met behulp van de Arraysclass, als volgt:

List<String> supplierNames = Arrays.asList("sup1", "sup2", "sup3");
System.out.println(supplierNames.get(1));

Maar let op: het is niet toegestaan om meer elementen aan die lijst toe te voegen, omdat het fixed-sizeis.

Antwoord 2, autoriteit 18%

Kan een interface niet instantiëren, maar er zijn weinig implementaties:

JDK2

List<String> list = Arrays.asList("one", "two", "three");

JDK7

//diamond operator
List<String> list = new ArrayList<>();
list.add("one");
list.add("two");
list.add("three");

JDK8

List<String> list = Stream.of("one", "two", "three").collect(Collectors.toList());

JDK9

// creates immutable lists, so you can't modify such list 
List<String> immutableList = List.of("one", "two", "three");
// if we want mutable list we can copy content of immutable list 
// to mutable one for instance via copy-constructor (which creates shallow copy)
List<String> mutableList = new ArrayList<>(List.of("one", "two", "three"));

Bovendien zijn er tal van andere manieren die door andere bibliotheken worden geleverd, zoals Guava.

List<String> list = Lists.newArrayList("one", "two", "three");

Antwoord 3, autoriteit 5%

Lijst is een Interface, je kunt geen interface instantiëren, omdat interface een conventie is, welke methoden je klassen moeten hebben. Om te instantiëren, heb je enkele realisaties (implementaties) van die interface nodig. Probeer de onderstaande code met zeer populaire implementaties van de List-interface:

List<String> supplierNames = new ArrayList<String>(); 

of

List<String> supplierNames = new LinkedList<String>();

Antwoord 4, autoriteit 2%

U moet ArrayList<String>of iets dergelijks gebruiken.

List<String>is een interface.

Gebruik dit:

import java.util.ArrayList;
...
List<String> supplierNames = new ArrayList<String>();

Antwoord 5, autoriteit 2%

Lijst is een interface en u kunt een interface niet initialiseren. Instantieer in plaats daarvan een implementatieklasse.

Vind ik leuk:

List<String> abc = new ArrayList<String>();
List<String> xyz = new LinkedList<String>();

Antwoord 6

In de meeste gevallen wilt u een eenvoudige ArrayList– een implementatie van List

Vóór JDK versie 7

List<String> list = new ArrayList<String>();

JDK 7 en later kunt u de diamant-operator gebruiken

List<String> list = new ArrayList<>();

Meer informatie vindt u hier Oracle-documentatie – Collecties

Antwoord 7

Lijst is slechts een interface, een definitie van een algemene lijst. U moet een implementatie van deze lijstinterface opgeven. De twee meest voorkomende zijn:

ArrayList– een lijst geïmplementeerd over een array

List<String> supplierNames = new ArrayList<String>(); 

LinkedList– een lijst die is geïmplementeerd als een onderling verbonden keten van elementen

List<String> supplierNames = new LinkedList<String>();

Antwoord 8

Afhankelijk van wat voor soort lijst je wilt gebruiken, zoiets als

List<String> supplierNames = new ArrayList<String>();

zou je op weg moeten helpen.

List is de interface, ArrayList is een implementatie van de List-interface. Meer implementaties die mogelijk beter aan uw behoeften voldoen, kunt u vinden in de JavaDocs van de Lijst-interface.

Antwoord 9

Als u alleen een onveranderlijkeList<T>wilt maken met slechts éénobject erin, kunt u deze API gebruiken:

List<String> oneObjectList = Collections.singletonList("theOnlyObject”);

Meer info: DOCS

Antwoord 10

Lijst is een interface. Je kunt geen lijst gebruiken om het te initialiseren.

 List<String> supplierNames = new ArrayList<String>();

Dit zijn de enkele lijst met een lijst met een lijst,

ArrayList, LinkedList, Vector

U kunt hiervan gebruiken volgens uw vereiste. Deze elke lessen hebben zijn eigen kenmerken.

Antwoord 11

Voor het geval dat iemand nog steeds rond deze vraag blijft. Omdat, ik zie een of twee nieuwe gebruikers opnieuw om dezelfde vraag en iedereen die vertelt, nee, niet dat je niet kunt doen, Beste Prudence , afgezien van alle hier gegeven antwoorden, zou ik willen bieden Extra informatie –
Ja, dat kan het daadwerkelijk doen, lijstlijst = nieuwe lijst ();
Maar ten koste van het schrijven van implementaties van alle methoden van interfaces.
Het idee is niet alleen lijst lijst = Nieuwe lijst (); maar

List<Integer> list = new List<Integer>(){
        @Override
        public int size() {
            // TODO Auto-generated method stub
            return 0;
        }
        @Override
        public boolean isEmpty() {
            // TODO Auto-generated method stub
            return false;
        }
        @Override
        public boolean contains(Object o) {
            // TODO Auto-generated method stub
            return false;
        }

….. enzovoort (kan niet alle methoden schrijven.)

Dit is een voorbeeld van Anonieme les. Het is correct als iemand zegt: Nee, je kunt geen interface makenen dat klopt. Maar je kunt nooit zeggen, Je KUNT NIET schrijven List list = new List();maar dat kun je duidelijk wel en dat is een harde uitspraak om dat je dat niet kunt doen.

Antwoord 12

We hebben soyuz-togemaakt om 1 probleem te vereenvoudigen: hoe Xtot Y(bijv. Stringtot Integer). Het construeren van een object is ook een soort conversie, dus het heeft een eenvoudige functie om Map, List, Sette construeren:

import io.thedocs.soyuz.to;
List<String> names = to.list("John", "Fedor");

Controleer het a.u.b. – het heeft een heleboel andere handige functies

Antwoord 13

In plaats van:

List<String> supplierNames = new List<String>();

Schrijf dit als je de nieuwste JDK gebruikt:

List<String> supplierNames = new ArrayList<>();

Dit is de juiste manier om een lijst te initialiseren.