Inicializace ArrayList v jedné linii

hlasů
2k

Chci vytvořit seznam možností pro účely testování. Zpočátku jsem toto:

ArrayList<String> places = new ArrayList<String>();
places.add(Buenos Aires);
places.add(Córdoba);
places.add(La Plata);

Pak jsem refactored kód následujícím způsobem:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList(Buenos Aires, Córdoba, La Plata));

Existuje lepší způsob, jak to udělat?

Položena 17/06/2009 v 05:10
zdroj uživatelem
V jiných jazycích...                            


35 odpovědí

hlasů
1k

Bylo by to jednodušší, pokud jste byli jen deklarovat jako List- to má být ArrayList?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Nebo pokud máte pouze jeden prvek:

List<String> places = Collections.singletonList("Buenos Aires");

To by znamenalo, že placesje neměnná (snaží změnit to způsobí, že UnsupportedOperationExceptionvýjimka být hozen).

Chcete-li proměnlivý seznam, který je beton ArrayListmůžete vytvořit ArrayListze seznamu neměnné:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
Odpovězeno 17/06/2009 v 05:15
zdroj uživatelem

hlasů
1k

Ve skutečnosti, pravděpodobně „nejlepší“ způsob, jak inicializovat ArrayListje metoda, kterou napsal, protože není nutné vytvořit nový Listv žádném případě:

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

Háček je v tom, že tam je docela dost psaní musí odkazovat na tuto listinstanci.

Existují alternativy, jako je například vytváření anonymní vnitřní třídu instance inicializátor (také známý jako „inicializace dvojité vzpěry“):

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

Nicméně, já nejsem moc rád tuto metodu, protože to, co jste skončili s, je podtřídou ArrayList, který má instance inicializátor, a tato třída je vytvořena jen vytvořit jeden objekt - to jen zdá, jako trochou přezbrojení ke mně.

Co by bylo hezké to v případě, že návrh Sbírka Literály k projektu Coin byl přijat (to bylo kritizované být zavedeny v Javě 7, ale není to pravděpodobné, že bude součástí Javy 8 obou.):

List<String> list = ["A", "B", "C"];

Bohužel to nebude vás tady pomoct, jak to bude inicializovat neměnný Listspíše než ArrayList, a navíc je to ještě není k dispozici, je-li to vůbec bude.

Odpovězeno 17/06/2009 v 05:13
zdroj uživatelem

hlasů
559

Jednoduchá odpověď

V Javě 8 nebo starší:

List<String> strings = Arrays.asList("foo", "bar", "baz");

To vám dá Listpodpořena pole, takže nemůže měnit délku.
Ale můžete volat List.set, takže je to stále proměnlivé.


V Javě 9:

List<String> strings = List.of("foo", "bar", "baz");

To vám dá neměnný List, takže to nemůže být změněn.
Což je to, co chcete, ve většině případů, kam jej prepopulating.


Kratší Odpověď

Můžete udělat Arrays.asListještě kratší se statickým importu:

List<String> strings = asList("foo", "bar", "baz");

Statický import:

import static java.util.Arrays.asList;  

Přičemž kterýkoli z nich moderní IDE navrhne a automaticky udělá za vás.
Například v IntelliJ IDEA stisku Alt+Entera zvolte Static import method....


Nicméně, i nedoporučujeme zkracovat Java 9 List.ofmetodu, protože má prostě ofstává matoucí.
List.ofJe už dost krátké a dobře čte.


používání Streamů

Proč to musí být List?
S Javou 8 nebo novější, můžete použít Stream, která je pružnější:

Stream<String> strings = Stream.of("foo", "bar", "baz");

Můžete spojovat Streams:

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

Nebo můžete jít z bodu A Streamdo A List:

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

Ale s výhodou, stačí použít Streambez vyzvednutí do A List.


Pokud jste opravdu konkrétně potřebujíjava.util.ArrayList

(Pravděpodobně ne.)
Chcete-li citovat JEP 269 (zvýraznění moje):

Tam je malý soubor případů použití pro inicializaci proměnlivý instanci kolekce s předem definovanou sadu hodnot. Je to obvykle lepší mít tyto přednastavené hodnoty se v neměnném kolekci a poté inicializovat proměnlivý kolekci pomocí kopírovacího konstruktoru.


Chcete-li oba přednastavit ArrayList a přidat k němu později (proč?), Využívání

List<String> strings = new ArrayList<>(asList("foo", "bar", "baz"));

nebo v Javě 9:

List<String> strings = new ArrayList<>(List.of("foo", "bar", "baz"));

nebo za použití Stream:

List<String> strings = Stream.of("foo", "bar", "baz")
                             .collect(toCollection(ArrayList::new));

Ale na druhou stranu, je to lepší, aby stačí použít Streampřímo namísto vyzvednutí do A List.


Program na rozhraní, není implementacích

Říkal jste, že jste prohlásil seznamu jako ArrayListv kódu, ale měli byste udělat jen to, že pokud používáte nějaký člen ArrayList, který není v List.

Které jsou s největší pravděpodobností nebude dělat.

Obvykle byste měli jen deklarovat proměnné od nejobecnější rozhraní, které budete používat (např Iterable, Collectionnebo List), a inicializovat je s konkrétní implementaci (např ArrayList, LinkedListnebo Arrays.asList()).

V opačném případě budete omezit svůj kód na tomto specifickém typu, a to bude těžší změnit, pokud chcete.

Například:

// Iterable if you just need iteration, for (String s : strings):
Iterable<String> strings = new ArrayList<>();   

// Collection if you also need .size() or .stream():
Collection<String> strings = new ArrayList<>(); 

// List if you also need .get(index):
List<String> strings = new ArrayList<>();       

// Don't declare a specific list implementation
// unless you're sure you need it:
ArrayList<String> strings = new ArrayList<>();  // You don't need ArrayList

Dalším příkladem by mohlo být vždy deklarovat proměnnou InputStreami když je to obvykle FileInputStream, nebo BufferedInputStream, protože jednoho dne brzy vy nebo někdo jiný bude chtít použít nějaký jiný druh InputStream.

Odpovězeno 09/09/2010 v 13:33
zdroj uživatelem

hlasů
99

Pokud potřebujete jednoduchý seznam o velikosti 1:

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

Pokud potřebujete seznam několika objektů:

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");
Odpovězeno 30/08/2011 v 05:33
zdroj uživatelem

hlasů
51

S Guava můžete psát:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

V Guava existují i další užitečné statické konstruktérů. Můžete si přečíst o nich zde .

Odpovězeno 29/07/2013 v 14:24
zdroj uživatelem

hlasů
31

Sbírka literals nedělal to do Javy 8, ale je možné použít Stream API inicializovat seznam v jednom poměrně dlouhé řadě:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

Pokud potřebujete, aby zajistily, že vaše Listje ArrayList:

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));
Odpovězeno 04/04/2014 v 00:21
zdroj uživatelem

hlasů
25
import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
Odpovězeno 12/05/2010 v 14:14
zdroj uživatelem

hlasů
21

Dalo by se vytvořit tovární metodu:

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

Ale to není o moc lepší než váš první refaktoringu.

Pro větší flexibilitu, může být generický:

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}
Odpovězeno 04/05/2010 v 01:57
zdroj uživatelem

hlasů
16

S Java 9, jak je navrženo v JDK Vylepšení návrhu - 269 , což by mohlo být dosaženo s použitím sběrných literals nyní as -

List<String> list = List.of("A", "B", "C");

Set<String> set = Set.of("A", "B", "C");

Také podobný přístup by se vztahovala na Mapstejně -

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

který je podobný návrh Collection literalu jak uvedl @coobird stejně. Dále upřesněno v doc JEP stejně -


alternativy

Změny jazykových byly považovány několikrát, a odmítl:

Projekt Coin Návrh, 29.března 2009

Projekt Coin Návrh, 30.března 2009

JEP 186 diskuse o lambda-dev, leden-březen 2014

Jazykové návrhy byly vyčleněny přednostně k návrhu knihovny na bázi jak je shrnuto v této zprávě.

Připoutaný četl o stejný ~> Jaký je smysl přetížených Convenience tovární metody

Odpovězeno 02/02/2017 v 17:36
zdroj uživatelem

hlasů
10

V Javě 9 můžeme snadno inicializovat ArrayListv jednom řádku:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

nebo

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Tento nový přístup Java 9 má mnoho výhod oproti těm předchozím:

  1. space Efficiency
  2. neměnitelnost
  3. závit Safe

Viz tento příspěvek pro více informací -> Jaký je rozdíl mezi List.of a Arrays.asList?

Odpovězeno 06/10/2017 v 01:16
zdroj uživatelem

hlasů
6

S Eclipse sbírek (dříve GS sbírky ), můžete napsat následující:

List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");

Také můžete být konkrétnější informace o typech a zda jsou proměnlivé a neměnné.

MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Můžete si také udělat to samé s Sady a tašky:

Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Poznámka: Jsem vývojář pro Eclipse sbírek.

Odpovězeno 28/01/2015 v 01:30
zdroj uživatelem

hlasů
6

O nejkompaktnější způsob, jak to udělat, je:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);
Odpovězeno 15/12/2014 v 11:44
zdroj uživatelem

hlasů
6

Jednoduše použít pod kódem takto.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};
Odpovězeno 21/09/2013 v 10:43
zdroj uživatelem

hlasů
5

Můžete použít níže uvedené příkazy:

Fragment kódu:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);
Odpovězeno 28/03/2017 v 20:18
zdroj uživatelem

hlasů
5

Tady je další způsob, jak:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());
Odpovězeno 28/02/2017 v 22:50
zdroj uživatelem

hlasů
4

Java 9 má následující metodu k vytvoření neměnný seznam:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

která je snadno přizpůsobit vytvořit proměnlivý seznamu, v případě potřeby:

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Podobné metody jsou k dispozici Seta Map.

Odpovězeno 06/12/2016 v 09:57
zdroj uživatelem

hlasů
4

Stejně jako Tom řekl :

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Ale protože jste si stěžoval, že chce ArrayList, měli byste nejprve vědět, že ArrayList je podtřídou seznamu a můžete jednoduše přidat tento řádek:

ArrayList<String> myPlaces = new ArrayList(places);

I když, že by mohl dělat vás si stěžují na ‚výkon‘.

V tomto případě to nedává smysl, aby mi, proč, protože váš seznam je předdefinovaná nebylo definováno jako pole (protože velikost je známa v době inicializace). A pokud to je volba pro vás:

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

V případě, že je vám to jedno z menších výkonnostních rozdílů pak si můžete také zkopírovat pole ArrayList velmi jednoduše:

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

Dobře, ale v budoucnu budete potřebovat o něco více než jen název místa, budete potřebovat kód země příliš. Za předpokladu, že je to stále předem definovaného seznamu, které se nikdy nezmění během run-time, pak je to montáž použít enumsadu, která by vyžadovala opětovné sestavení, pokud je seznam bylo třeba v budoucnu změnit.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

stal by se:

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

ENUM je mít statickou valuesmetodu, která vrací pole obsahující všechny hodnoty z výčtu v pořadí, v jakém jsou deklarovány, například:

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

V tom případě myslím, že by nebylo nutné vaši ArrayList.

PS Randyaa prokázaly další příjemný způsob, pomocí statické metody nástroj Collections.addAll .

Odpovězeno 17/06/2013 v 18:57
zdroj uživatelem

hlasů
4

(Měl by být komentář, ale příliš dlouho, takže nová odpověď). Jak již bylo zmíněno jiní se Arrays.asListmetoda je stanovena velikost, ale to není jediný problém s ním. To také nezpracovává dědictví velmi dobře. Předpokládejme například, že máte k dispozici následující:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

Výše uvedené vede k chybě kompilátoru, protože List<B>(což je to, co je vrácena Arrays.asList) není podtřídou List<A>, i když si můžete přidat objekty typu B do List<A>objektu. Chcete-li tento postup obejít, je třeba udělat něco jako:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

To je pravděpodobně nejlepší způsob, jak jít o tom to, esp. Pokud potřebujete nespoutaný seznamu, nebo je potřeba použít dědičnost.

Odpovězeno 06/06/2013 v 06:44
zdroj uživatelem

hlasů
3

Můžete použít StickyListz Cactoos :

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);
Odpovězeno 25/06/2017 v 17:48
zdroj uživatelem

hlasů
3
List<String> names = Arrays.asList("2","@2234","21","11");
Odpovězeno 22/06/2014 v 09:12
zdroj uživatelem

hlasů
2

Ano, pomocí polí můžete inicializovat seznamu pole v jedné linii,

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");
Odpovězeno 13/09/2016 v 05:54
zdroj uživatelem

hlasů
2

Zkuste s tímto kódem řádek:

Collections.singletonList(provider)
Odpovězeno 16/05/2016 v 13:45
zdroj uživatelem

hlasů
1

Někdy cítím, že lidé by jednoduše použít Groovy a nechat Java odpočinout v klidu. Dobrá věc je, že to běží na JVM, takže můžete zkopírovat vložit čistého kódu Java kdekoli v Groovy souboru, a to bude jen pracovat.

O deklarovat seznam v jednom řádku, je to, jak to vypadá v Groovy:

def list1 = [1,2,3]

To je to, maan !!!

Zde je více informací o Groovy seznamech .

Extras

Deklarování mapa Groovy v jednom řádku:

def map1 = [key1:1,key2:2]

Zde je více informací o Groovy mapách .

Čtení souboru JSON,

{ "map1":{"map2":{"key":"value1"}}}

v jednom řádku takto:

String value = new JsonSlurper().parse("path\\to\\file")["map1"]["map2"]["key"]

nebo

String value = new JsonSlurper().parse("path\\to\\file").map1.map2.key

V obou případech valuese value1.

Představte si, že to samé se Jackson API. Musíte napsat odpovídající objektů POJO pro MAP1 a MAP2. Kompilovat. Také pokaždé JSON změní, budete muset odrážet tyto změny v POJO. Tento zcela maří cíl učinit funkčnost JSON konfigurovatelné. To je smrtící configure-code-překompilujte řetězec. Není to jen nastavit a jít.

(Někdy) pláču, když jsem byl požádán, abych používat Java. Proč svět proč ???? (nebo prosím Pouč mě, jestli se mýlím ... sníží hodně mé bolesti v Javě World)

Odpovězeno 30/11/2016 v 11:59
zdroj uživatelem

hlasů
1

Zde je kód by AbacusUtil

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

Prohlášení: Jsem vývojář AbacusUtil.

Odpovězeno 28/11/2016 v 19:56
zdroj uživatelem

hlasů
1
Collections.singletonList(messageBody)

Pokud byste museli mít seznam jednu položku !

Kolekce je z java.util balíčku.

Odpovězeno 03/04/2015 v 09:30
zdroj uživatelem

hlasů
1

V Java, můžete to udělat

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Jak bylo zdůrazněno, že je nutné provést inicializaci dvojí ortéza:

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

Ale to vás může nutit do přidáním anotace @SuppressWarnings("serial")nebo generovat sériový UUID což je nepříjemné. Také většina kód formátovače budou rozbalovat, že do několika závěrce / liniemi.

Případně si můžete udělat

List<String> places = Arrays.asList(new String[] {"x", "y" });

ale pak se budete chtít udělat @SuppressWarnings("unchecked").

Také podle javadoc, měli byste být schopni to udělat:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Ale nejsem schopen dostat se do kompilace s JDK 1.6.

Odpovězeno 13/02/2012 v 22:47
zdroj uživatelem

hlasů
0

zajímavě nikdo-vložka s druhou přetížené Stream::collect metody je uveden

ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );
Odpovězeno 04/10/2019 v 18:04
zdroj uživatelem

hlasů
0

Jsem vytvoření seznamu messageTemplate z XML souboru uloženého v dráze před statickým kontextu

public final class TemplateStore {

    private TemplateStore(){}

    private static final String [] VERSIONS = {"081"};
    private static final String TEMPLATE_FILE_MASK = "template/EdiTemplates_v%s.xml";
    private static final String ERROR = "Error In Building Edifact Message Template Store";

    public static final List<MessageTemplate> TEMPLATE_LIST = Arrays.stream(VERSIONS)
            .map(version -> TemplateStore.class
                    .getClassLoader().getResourceAsStream(String.format(TEMPLATE_FILE_MASK, version)))
            .map(inputStream -> {
                try {
                    return ((EdiTemplates) JAXBContext.newInstance(EdiTemplates.class).createUnmarshaller()
                            .unmarshal(inputStream)).getMessageTemplate();
                } catch (JAXBException e) {
                    throw new IllegalArgumentException(ERROR, e);
                }})
            .flatMap(Collection::stream)
            .collect(Collectors.toList());
}
Odpovězeno 04/07/2019 v 09:23
zdroj uživatelem

hlasů
0

Proč ne vytvořit jednoduchý užitkovou funkci, která dělá to?

static <A> ArrayList<A> ll(A... a) {
  ArrayList l = new ArrayList(a.length);
  for (A x : a) l.add(x);
  return l;
}

ll“ Je zkratka pro „doslovnou seznamu“.

ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");
Odpovězeno 04/12/2017 v 11:23
zdroj uživatelem

hlasů
0

Nejlepší způsob, jak to udělat:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

Stačí vytvořit funkci, která může mít tolik prvků, kolik chcete, a nazývat to je přidat v jedné linii.

Odpovězeno 17/07/2016 v 18:31
zdroj uživatelem

hlasů
0

Pro mě Arrays.asList () je nejlepší a pohodlný jeden. Vždycky jsem chtěl inicializovat tímto způsobem. Pokud jste začátečník v Javě sbírek pak bych rád, abyste odkazovat ArrayList inicializaci

Odpovězeno 07/12/2014 v 05:37
zdroj uživatelem

hlasů
-1

Vyzkoušejte tohle:

Arrays.asList("yellow", "green","blue");
Collections.singletonList(new String[]{"yellow", "green","blue"});
Arrays.stream((new String[]{"yellow", "green", "blue"})).collect(Collectors.toList());
Odpovězeno 12/07/2019 v 10:48
zdroj uživatelem

hlasů
-1

Ve skutečnosti je to možné, aby to v jednom řádku:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})
Odpovězeno 02/06/2013 v 14:34
zdroj uživatelem

hlasů
-3
public static <T> List<T> asList(T... a) {
    return new ArrayList<T>(a);
}

Jedná se o implementaci Arrays.asList, takže si mohl jít s

ArrayList<String> arr = (ArrayList<String>) Arrays.asList("1", "2");
Odpovězeno 31/07/2012 v 14:22
zdroj uživatelem

hlasů
-4

V Apple WebObjects Foundation rámce, můžete to udělat.

NSArray<String> places1 = new NSArray<String>("Buenos Aires", "Córdoba", "La Plata");
NSMutableArray<String> places2 = new NSMutableArray<String>("Buenos Aires", "Córdoba", "La Plata");
List<String> places3 = new NSMutableArray<String>("Buenos Aires", "Córdoba", "La Plata");

Rámec WebObjects Foundation byl portován z Objective-C Java více než deseti lety a byl aktualizován po Java 5 přidána podpora pro generik ... Zajímalo by mě, proč se něco podobného nebyla implementována do tříd Java sbírky.

Odpovězeno 25/04/2016 v 18:47
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more