Créer une liste de tableaux de valeurs uniques

J'ai, en Java, une liste de tableaux avec des valeurs (nombre de lignes, c'est juste un extrait)

20/03/2013 23:31:46 6870 6810 6800 6720 6860 6670 6700 6650 6750 6830 34864 34272
20/03/2013 23:31:46 6910 6780 6800 6720 6860 6680 6620 6690 6760 6790 35072 34496

Où les deux premières valeurs sont des chaînes de caractères qui contient les données et sont stockés dans un seul élément.

Ce que je veux faire est de comparer les données de la chaîne éléments et en supprimant par exemple la deuxième, et tous les éléments visés à la ligne.

Pour l'instant, j'en ai utilisé un pour le cycle que tous les 13 éléments compare la chaîne (afin de comparer uniquement les données de chaînes de caractères)

Ma Question: puis-je mettre en œuvre d'autres de meilleures solutions?

C'est mon code:

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Downsampler {
public static void main(String[] args) throws Exception{
//The input file
Scanner s = new Scanner(new File("prova.txt"));
//Saving each element of the input file in an arraylist 
ArrayList<String> list = new ArrayList<String>();
while (s.hasNext()){
list.add(s.next());
}
s.close();
//Arraylist to save modified values
ArrayList<String> ds = new ArrayList<String>();
//
int i;
for(i=0; i<=list.size()-13; i=i+14){
//combining the first to values to obtain data  
String str = list.get(i)+" "+list.get(i+1);
ds.add(str);
//add all the other values to arraylist ds
int j;
for(j=2; j<14; j++){
ds.add(list.get(i+j));
}
//comparing data values
int k;  
for(k=0; k<=ds.size()-12; k=k+13){
ds.get(k); //first data string element  
//Comparing with other strings and delete
//TODO  
}
}
}
}

Vous devriez poster votre question ici: codereview.stackexchange.com
Le Code n'est pas terminé 1 accolades est manquant, de sorte s'il vous plaît poster complte code
maintenant, devrait être ok, même si la comparaison des valeurs n'est pas mis en œuvre à tous

InformationsquelleAutor alessandrob | 2013-07-09

arraylist java

39

Créer une liste de tableaux de valeurs uniques

Vous pouvez utiliser Set.toArray() méthode.

Une collection qui ne contient pas les éléments en double. Plus formellement, les jeux de
contiennent pas de paire d'éléments e1 et e2 tels que e1.equals(e2), et à
plus un élément de valeur null. Comme le laisse entendre son nom, cette interface modèles
l'ensemble mathématique de l'abstraction.

http://docs.oracle.com/javase/6/docs/api/java/util/Set.html
- Ok, mais comment je peux faire pour supprimer toutes les valeurs liées à la chaîne de données? Je veux dire, si je trouve une chaîne de données égale à une autre, je dois supprimer toutes les valeurs liées à cette
- Set.toArray() ne pas garder les éléments de commande. Est-il un moyen de maintenir l'ordre?
- Pourquoi -1? veuillez expliquer
- Une liste de tableaux à garder les éléments de commande, Jeu qui ne fonctionne pas. Une liste de tableaux de valeurs uniques n'est pas la même que celle de la transformation d'un Ensemble à une liste de tableaux. Je suis venu à cette question, la recherche d'une liste de tableaux de valeurs uniques et je n'ai pas trouver encore.
- En complément... à la Recherche d'une bonne adéquation de la mise en œuvre d'une liste de tableaux de valeurs uniques.
- vous pouvez éventuellement utiliser LinkedHashSet: docs.oracle.com/javase/8/docs/api/java/util/LinkedHashSet.html ce qui permettra de conserver l'ordre d'insertion. Dépend de quel ordre vous souhaitez conserver les doublons.
InformationsquelleAutor Dmitry Zagorulkin
58

Essayez de vérifier les doublons avec un .contains() méthode sur la liste de tableaux, avant d'ajouter un nouvel élément.

Il ressemblerait à quelque chose comme ceci
```
   if(!list.contains(data))
list.add(data);
```
Qui devrait éviter les doublons dans la liste, ainsi que de ne pas gâcher l'ordre des éléments, comme les gens semblent chercher.
- Cela va fonctionner, mais n'oubliez pas de faire ce synchronisée, sinon vous attirer des ennuis
- Cela affecte les performances si il y a de grandes données? Je pense que ça va.
- C'est un abonnement d'essai. Devrait être un O(log n) appel au plus. Si vous souhaitez conserver l'ordre des éléments, je ne pense pas que nous pouvons le mieux c'.
- Comme @Amt87 mentionné les performances seront affectées pour des données de grande taille. L'adhésion d'essai dans une ArrayList est O(n), pas de O(log n). Si vous êtes à la recherche en O(n^2) lorsque vous remplissez la liste.
InformationsquelleAutor Anudeep Bulla

HashSet hs = new HashSet();
hs.addAll(arrayList);
arrayList.clear();
arrayList.addAll(hs);

InformationsquelleAutor Amol Suryawanshi

3

Vous pouvez utiliser un Ensemble. C'est une collection qui n'accepte pas les doublons.

InformationsquelleAutor Sorin

Utilisation Set

      ...
Set<String> list = new HashSet<>();
while (s.hasNext()){
list.add(s.next());
}
...

InformationsquelleAutor Mohammad Changani

 //Saving each element of the input file in an arraylist 
ArrayList<String> list = new ArrayList<String>();
while (s.hasNext()){
list.add(s.next());
}
//That's all you need
list = (ArrayList) list.stream().distinct().collect(Collectors.toList());

Il travaille à partir de l'api de niveau 24. ne prend pas en charge ci-dessous les versions

InformationsquelleAutor Sadequer Rahman

2

Vous pouvez facilement le faire avec un Hashmap. Vous avez évidemment une clé (qui est la Chaîne de données) et de certaines valeurs.

Boucle sur toutes vos lignes et les ajouter à votre Carte.
```
Map<String, List<Integer>> map = new HashMap<>();
...
while (s.hasNext()){
String stringData = ...
List<Integer> values = ...
map.put(stringData,values);
}
```
Noter que dans ce cas, vous devrez garder les dernier occurence de lignes dupliquées. Si vous préférez garder la première occurence et en supprimant les autres, vous pouvez ajouter une case avec Map.containsKey(String stringData); avant de les mettre dans la carte.

InformationsquelleAutor Arnaud Denoyelle
2

Assez en retard à la fête, mais voici mes deux cents:

Utiliser un LinkedHashSet

Je suppose que vous avez besoin est une collection qui:
- interdit l'insertion de doublons;
- conserve l'ordre d'insertion.
LinkedHashSet fait cela. L'avantage par rapport à l'aide d'un ArrayList est que LinkedHashSet a une complexité de O(1) pour la contains fonctionnement, par opposition à ArrayList, qui a O(n).

^{bien sûr, vous avez besoin pour mettre en œuvre votre objet equals et hashCode méthodes correctement.}

InformationsquelleAutor MC Emperor

Juste Remplacer le booléen méthode equals() de l'objet personnalisé. Disons que vous avez une liste de tableaux avec champ personnalisé f1, f2, ... remplacer

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof CustomObject)) return false;
CustomObject object = (CustomObject) o;
if (!f1.equals(object.dob)) return false;
if (!f2.equals(object.fullName)) return false;
...
return true;
}

et vérifier à l'aide de ArrayList exemple de la méthode contains (). C'est tout.

InformationsquelleAutor shuvomiah

0

Si vous avez besoin de valeurs uniques, vous devez utiliser la mise en œuvre de la SET interface
- N'est pas accessible par l'INDEX. Pas la même!
InformationsquelleAutor Sashi Kant

Vous pouvez lire à partir du fichier de la carte, où la clé est la date et l'ignorer si la toute la ligne si la date est déjà dans la carte

        Map<String, List<String>> map = new HashMap<String, List<String>>();
int i = 0;
String lastData = null;
while (s.hasNext()) {
String str = s.next();
if (i % 13 == 0) {
if (map.containsKey(str)) {
//skip the whole row
lastData = null;
} else {
lastData = str;
map.put(lastData, new ArrayList<String>());
}
} else if (lastData != null) {
map.get(lastData).add(str);
}
i++;
}

InformationsquelleAutor Natalia

- Je utiliser de la classe helper. Pas sûr que c'est bon ou mauvais

public class ListHelper<T> {
private final T[] t;
public ListHelper(T[] t) {
this.t = t;
}
public List<T> unique(List<T> list) {
Set<T> set = new HashSet<>(list);
return Arrays.asList(set.toArray(t));
}
}

D'utilisation et de test:

import static org.assertj.core.api.Assertions.assertThat;
public class ListHelperTest {
@Test
public void unique() {
List<String> s = Arrays.asList("abc", "cde", "dfg", "abc");
List<String> unique = new ListHelper<>(new String[0]).unique(s);
assertThat(unique).hasSize(3);
}
}

Ou Java8 version:

public class ListHelper<T> {
public Function<List<T>, List<T>> unique() {
return l -> l.stream().distinct().collect(Collectors.toList());
}
}
public class ListHelperTest {
@Test
public void unique() {
List<String> s = Arrays.asList("abc", "cde", "dfg", "abc");
assertThat(new ListHelper<String>().unique().apply(s)).hasSize(3);
}
}

InformationsquelleAutor lapkritinis

Vous devez vous connecter pour publier un commentaire.

Utiliser un LinkedHashSet

Utiliser un `LinkedHashSet`