Spliter un message binaire - critère de découpage

Bonjour à tous,

Voici ce que je souhaite obtenir. En entrée, j'ai un message binaire au format String que je souhaite découper à chaque changement de bit.
J'ai donc pensé à la méthode split() que je viendrais appliquer à messageBinaire avec pour critère de découpage la détection du schéma "01" ou "10" mais je n'arrive pas à traduire mon critère de découpage en langage JAVA.

Entrée :
String messageBinaire = "01000011";

Découpage :
String[] sortie = messageBinaire.split(critère de découpage à déterminer);

Sortie :
un tableau de String comme suit : sortie = {0,1,0000,11}

PS : Je prends bien évidemment toutes suggestions mais j'aimerais aussi savoir qu'elle serait l'expression régulière qui me permettrait de faire un découpage lorsque 01 ou 10 est détecté.

Merci d'avance !

Tu fait une détection de changement d'état basique :

On suppose que tu as une pile A et une case B ou tu vide les éléments de A.


Tu prend un élément dans A :
Si B est rempli avec des éléments différents de l'élément pris. Tu vide B, puis tu ajout ton élément à B.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

char[] liste = { '0', '0', '1', '1', '1', '0', '1', '0', '1', '0' }; String B = ""; char inB = ' '; for (char element : liste) { if (inB == ' ') { B = B + element; inB = element; } else { if (inB == element) { B = B + element; } else { System.out.println(B); inB = element; B = String.valueOf(element); } } } System.out.println(B);

---

Bien sûr, c'est la version idiote. On devrait utiliser un StringBuilder au minimum et avoir une variable pour contenir le retour au lieu de l'afficher.

Mais la détection de changement d'état est une conception de base. Tellement basique qu'elle est considéré comme partie intégrante de l’électronique...

Cordialement,
Patrick Kolodziejczyk.

Merci Kolodz pour ta réponse,

Je vais la tester. Mais n'y a-t-il pas une méthode plus courte que celle-ci basée sur la méthode split et exploitant les expressions régulières ?

Non, sachant que la méthode slipt supprime le caractère de séparation.
Et les regex, on ne les utilisent que quand on sait déjà ce qu'on fait. Ce qui n'est pas ton cas.

Cordialement,
Patrick Kolodziejczyk.

EDIT :
Version Regex :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public static void main(String[] args) { String tomatch = "00101100001010000100000010001110"; String regex = "(1+)*(0+)*"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(tomatch); while (matcher.find()) { if (matcher.group(1) != null) { System.out.println(matcher.group(1)); } if (matcher.group(2) != null) { System.out.println(matcher.group(2)); } } }

---

Je te dé-conseil de l'utiliser, car c'est du code magico magic pour toi. Je suis sûr que tu es totalement incapable de comprendre ce que fait ce code. Et par conséquence, si tu dois le modifier tu n'y arrivera pas. Et cela ne te fait pas monter en compétence non plus. Cela ne sert à rein d'avoir un morceau de code qu'on ne maitrise pas dans son projet.
De plus la version "basique" est peut-être un peu plus longue, mais celle-ci est beaucoup moins consommatrice que cela soit en mémoire ou en temps.

Merci Kolodz pour ta réponse.

J'ai commencé à me documenter sur les expressions régulières. Donc je suis de plus en plus capable de comprendre ces expressions.
En fait, j'avais déjà un code (à coups de boucle for et de if mais qui me paraissait très artisanal) qui me donnait le résultat souhaité. Mais pour progresser et apprendre de nouvelles choses, je m'efforce de parvenir au résultat souhaité de diverses manières et je pensais qu'une méthode similaire à split() mais ne supprimant pas les caractères de découpage existait. De même, il faut progressivement mettre les mains dans les expressions régulières pour un jour vraiment les maîtriser.

@+

Quand je dis que tu n'as pas les bases, c'est que tu n'as pas les bases algorithmiques.
Car la fonction qui découpe ta chaîne proprement est en complexité O(n) au mieux. Ce qui est le cas de ce que je t'ai présenté dans mon premier poste.
Celui-ci nécessite qu'une seule boucle et devrait être à la porter de tout développeur. Si tu n'arrive pas à comprendre ou créer ce genre d'algorithme, tu aura forcement des problèmes lors de l'utilisation des expressions régulières qui demande beaucoup plus de connaissance.

Cordialement,
Patrick Kolodziejczyk.

Je confirme que la réalisation de cet "exercice" ne nécessite nullement l'utilisation des expressions régulières. Celles-ci forment un langage propre qui est bien moins naturel que la programmation "procédurale".

La recherche de sous-chaîne ou de manière encore plus élémentaire, la recherche de changement d'états sont des exercices triviaux qu'il convient de maîtriser avant de s'attaquer à d'autres domaines beaucoup plus pointus.

Sur le principe, il suffit de se rappeler le dernier état (caractère et position) et de la comparer à l'état courant. Si les caractères ne correspondent pas, il suffit d'extraire la chaîne correspondant à la dernière position mémorisée et la position précédente. A ce moment, l'état courant est mémorisé. Il faut bien préter attention à traiter l'état mémorisé en sortie de boucle.


PS : l'expression régulière est la suivante "([01])\\1*". Elle reprend l'algorithme cité plus haut : mémorisation du dernier état valide et recherche de séquence.

Citation:

---

Envoyé par kolodz

Quand je dis que tu n'as pas les bases, c'est que tu n'as pas les bases algorithmiques.
Car la fonction qui découpe ta chaîne proprement est en complexité O(n) au mieux. Ce qui est le cas de ce que je t'ai présenté dans mon premier poste.
Celui-ci nécessite qu'une seule boucle et devrait être à la porter de tout développeur. Si tu n'arrive pas à comprendre ou créer ce genre d'algorithme, tu aura forcement des problèmes lors de l'utilisation des expressions régulières qui demande beaucoup plus de connaissance.

Cordialement,
Patrick Kolodziejczyk.

---

Je n'ai peut-être pas utilisé le bon terme. Lorsque je souhaitais une méthode "plus courte" je ne voulais pas dire "plus simple". La méthode que tu as proposé initialement tenait sur 18 lignes et je souhaitais simplement savoir comment la rendre plus compacte, ayant déjà compris cette méthode.

Le premier if est remplaçable par une initialisation hors de la boucle for :
inB = liste[0];Cela ne fait plus que 14 lignes...
Dont au moins une qui devrait être un paramètre de ta fonction... Après, un code compacte ne veux pas dire un bon code. Sinon, je t'écris le même code sur 9 lignes en ne respectant pas les conventions de codage...

Cordialement,
Patrick Kolodziejczyk.

Code:

---

String[] sortie = messageBinaire.split("(?<=0)(?=1)|(?<=1)(?=0)");

---

(?<=..) est un test arrière. (lookbehind)
(?=..) est un test avant. (lookahead)

Aucune de ces deux assertions ne consomme de caractères donc la pattern matche un chaîne vide mais à une position précise de la chaîne.

En bon français: la position précédée par un 0 et suivie par un 1, ou précédée par un 1 et suivie par un 0.