Mise en œuvre de la liste C# ... en Java

Question

J'apprends Java et j'essaie de faire quelque chose que j'ai toujours fait en C# ... en Java.

Le but est d'envelopper la classe "MyItem" dans une liste de "MyItems". Cela rend plus facile à raisonner (MyItems est beaucoup plus facile à lire/comprendre que List<MyItem> ... ou, disons, je dois en faire quelque chose de plus compliqué comme IEnumerable<KeyValuePair<string,List<Dictionary<int,bool>>>> ... puis demander un MyKVPDictionaries au lieu de List<IEnumberaable<KeyValuePair<...>>>>>). Il suffit de regarder autour ... Il semble que C# vous permet de conserver les implémentations par défaut des choses (Regardez ci-dessous, .Add fonctionne seulement).

En regardant Java ... existe-t-il un moyen d'implémenter une liste comme fait en C#? Ou dois-je manuellement implémenter manuellement les différentes parties de la liste? (.add, .list, .contains, etc). Ci-dessous j'ai une implémentation "de base" d'un Class ... et un en C#.

Est-ce vraiment beaucoup plus de travail pour implémenter class MyItems implements List<MyItem> en Java ou est-ce que je manque quelque chose pour simplifier le processus?

(Le code Java est uniquement le fichier de classe MyItems.java avec les tronçons Resharper "Implémenter automatiquement les membres manquants" via IntelliJ).

C# Version .NetFiddle:

using System; 
using System.Collections.Generic; 

public class Program 
{ 
    public static void Main() 
    {  
     var myItems = new MyItems(); 
     myItems.Add(new MyItem("Hello")); 
     myItems.Add(new MyItem(" ")); 
     myItems.Add(new MyItem("World")); 
     myItems.Add(new MyItem("!")); 

     foreach(var item in myItems) 
      Console.Write(item.Name); 
    } 
} 

public class MyItems : List<MyItem> 
{ 

} 

public class MyItem 
{ 
    public MyItem(string name) 
    { 
     Name = name; 
    } 
    public string Name { get; private set; } 
} 

Java Version start/stub:

package items; 

import java.util.Collection; 
import java.util.Iterator; 
import java.util.List; 
import java.util.ListIterator; 

public class MyItems implements List<MyItem> { 
    @Override 
    public int size() { 
     return 0; 
    } 

    @Override 
    public boolean isEmpty() { 
     return false; 
    } 

    @Override 
    public boolean contains(Object o) { 
     return false; 
    } 

    @Override 
    public Iterator<MyItem> iterator() { 
     return null; 
    } 

    @Override 
    public Object[] toArray() { 
     return new Object[0]; 
    } 

    @Override 
    public <T> T[] toArray(T[] a) { 
     return null; 
    } 

    @Override 
    public boolean add(MyItem generatePreSignedUrl) { 
     return false; 
    } 

    @Override 
    public boolean remove(Object o) { 
     return false; 
    } 

    @Override 
    public boolean containsAll(Collection<?> c) { 
     return false; 
    } 

    @Override 
    public boolean addAll(Collection<? extends MyItem> c) { 
     return false; 
    } 

    @Override 
    public boolean addAll(int index, Collection<? extends MyItem> c) { 
     return false; 
    } 

    @Override 
    public boolean removeAll(Collection<?> c) { 
     return false; 
    } 

    @Override 
    public boolean retainAll(Collection<?> c) { 
     return false; 
    } 

    @Override 
    public void clear() { 

    } 

    @Override 
    public MyItem get(int index) { 
     return null; 
    } 

    @Override 
    public MyItem set(int index, MyItem element) { 
     return null; 
    } 

    @Override 
    public void add(int index, MyItem element) { 

    } 

    @Override 
    public MyItem remove(int index) { 
     return null; 
    } 

    @Override 
    public int indexOf(Object o) { 
     return 0; 
    } 

    @Override 
    public int lastIndexOf(Object o) { 
     return 0; 
    } 

    @Override 
    public ListIterator<MyItem> listIterator() { 
     return null; 
    } 

    @Override 
    public ListIterator<MyItem> listIterator(int index) { 
     return null; 
    } 

    @Override 
    public List<MyItem> subList(int fromIndex, int toIndex) { 
     return null; 
    } 
} 

Answer 1

de type Java List est une interface, la contrepartie de C# 's IList. Vous devrez écrire la plupart des méthodes à partir de zéro si vous voulez l'implémenter. La contrepartie de classe concrète de C# List serait Java de ArrayList:

public class MyItems extends ArrayList<MyItem> {