IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage Java Discussion :

Manipulations de Bits et Octets


Sujet :

Langage Java

  1. #1
    Futur Membre du Club
    Inscrit en
    Décembre 2010
    Messages
    4
    Détails du profil
    Informations forums :
    Inscription : Décembre 2010
    Messages : 4
    Par défaut Manipulations de Bits et Octets
    Bonjour,

    Je dois faire des rotations de bits sur un tableau de 8 octets. Par exemple, si la rotation doit se faire sur 10 bits et qu'il faut décaler vers la droite, il faut que l'octet le plus à droite et les 2 premiers bits de l'octet à côté se retrouvent à gauche, et tout les autres octets doivent se décaler de 10 bits vers la droite. Le bit n°10 se retrouve à la position 0, le n°11 à la position 1, etc. Au final c'est une opération "RoR" quoi.


    Comment faire ?

    Merci beaucoup

  2. #2
    Modérateur
    Avatar de Alkhan
    Homme Profil pro
    ingénieur full stack
    Inscrit en
    Octobre 2006
    Messages
    1 232
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur full stack

    Informations forums :
    Inscription : Octobre 2006
    Messages : 1 232
    Par défaut
    bonjour,

    Pour le décalage de bits tu trouveras ton bonheur dans penser en java 2.
    Regarde la section "Les opérateurs de décalage"
    Il n'y a pas de problème, il n'y a que des solutions.
    Cependant, comme le disaient les shadoks, s'il n'y a pas de solution, c'est qu'il n'y a pas de problème.
    Si toutefois le problème persiste, la seule solution restante est de changer le périphérique qui se trouve entre la chaise et l'écran

    Mes Articles : Mon premier article est sur le language D
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  3. #3
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 582
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 582
    Par défaut
    Notons que, bien qu'il soit effectivement possible de le faire, grâce à ces opérateurs de décalage et aux opérateur booléens bit-à-bit...

    C'est bel et bien très chiant à faire.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  4. #4
    Futur Membre du Club
    Inscrit en
    Décembre 2010
    Messages
    4
    Détails du profil
    Informations forums :
    Inscription : Décembre 2010
    Messages : 4
    Par défaut
    Citation Envoyé par Alkhan Voir le message
    bonjour,

    Pour le décalage de bits tu trouveras ton bonheur dans penser en java 2.
    Regarde la section "Les opérateurs de décalage"
    Merci pour ton aide

    Cependant, la rotation doit se faire sour l'ensemble des bytes dans le tableau (rotation de 3 vers la gauche = les 3 bits de poid fort d'un octets deviennent les 3 bits de poids faible de l'octet qui est à sa gauche).

    Encore merci.

  5. #5
    Membre éprouvé
    Homme Profil pro
    Développeur de jeux vidéo
    Inscrit en
    Décembre 2005
    Messages
    109
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : Décembre 2005
    Messages : 109
    Par défaut
    Peut être que le java.math.BigInteger peut te simplifier la tâche.
    Par exemple avec le constructeur public BigInteger(int signum, byte[] magnitude) et les méthodes de décalage de bits.

  6. #6
    Futur Membre du Club
    Inscrit en
    Décembre 2010
    Messages
    4
    Détails du profil
    Informations forums :
    Inscription : Décembre 2010
    Messages : 4
    Par défaut
    Citation Envoyé par Volune Voir le message
    Peut être que le java.math.BigInteger peut te simplifier la tâche.
    Par exemple avec le constructeur public BigInteger(int signum, byte[] magnitude) et les méthodes de décalage de bits.

    Merci beaucoup Volune ! BigInteger m'a déjà beaucoup aidé

    J'aurais encore une question:

    Auriez-vous une méthode pour "aisément" récupérer les bits qui ont été décalés vers la gauche pour les remettre en début sans faire ça de cette manière:

    - Application d'un masque pour récupérer les 5 derniers bits
    - Division successives pour enlever tout les bits qui étaient à 0 dans le masque
    - Report && nombre shifté.


    Encore merci

  7. #7
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 582
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 582
    Par défaut
    Je sais pas si ça te paraîtra bien plus simple, mais :

    Citation Envoyé par Jiraiya-08 Voir le message
    - Division successives pour enlever tout les bits qui étaient à 0 dans le masque
    Tu peux utiliser un right-shift au lieu de ça :

    Ou plus simplement :

    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  8. #8
    Membre chevronné
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    342
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 342
    Par défaut
    bonjour,

    si tu a besoin de faire beaucoup de traitement bit à bit je ferais une class qui vas permettre de faire cela de manière simple.

    j'avais fait ceci (même si on peux faire plus performant avec les opérateur bit a bit):

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    import java.util.LinkedList;
     
    /**
     *
     * @author Amaridon Florent
     */
    public class BitList extends LinkedList<Boolean>{
     
            /**
             * Charge un tableau de byte
             * @param bytes
             */
            public void loadByteArray(byte[] bytes) {
                this.clear();
                for (int x = bytes.length - 1; x >= 0; x--) {
                    int b = bytes[x];
                    for (int i = 0; i < 8; i++) {
                        int tmp = b & 0x01;
                        boolean bool = tmp > 0 ? true : false;
                        this.addLast(new Boolean(bool));
                        b = b >> 1;
                    }
     
                }
            }
     
            /**
             * Effectue une rotation sur la gauche
             * @param start bit de poid le plus faible a prendre en compte dans la rotation
             * @param end nombre de bit a faire tourner
             */
            public void shiftLeft(int start, int end) {
                Boolean tmp = this.remove(start + end - 1);
                this.add(start, tmp);
            }
     
            /**
             * Effectue une rotation sur la droite
             * @param start start bit de poid le plus faible a prendre en compte dans la rotation
             * @param end nombre de bit a faire tourner
             */
            public void shiftRight(int start, int end) {
                Boolean tmp = this.remove(start);
                this.add(start + end - 1, tmp);
            }
     
            /**
             *
             * @param start index du bit de debut
             * @param end index du bit de fin
             * @param loops nombre de decalage
             */
            public void shiftRight(int start, int end, int loops) {
                for (int i = 0; i < loops; i++) {
                    this.shiftRight(start, end);
                }
            }
     
            /**
             *
             * @param start index du bit de debut
             * @param end index du bit de fin
             * @param loops nombre de decalage
             */
            public void shiftLeft(int start, int end, int loops) {
                for (int i = 0; i < loops; i++) {
                    this.shiftLeft(start, end);
                }
            }
     
            /**
             *
             * @param index index du bit a modifier
             * @param val valeur a lui donnée
             * @throws IndexOutOfBoundsException
             */
            public void setBit(int index, boolean val) throws IndexOutOfBoundsException{
                this.remove(index);
                this.add(index, new Boolean(val));
            }
     
            @Override
            public String toString() {
                StringBuilder sb = new StringBuilder();
                for (int i = this.size() - 1; i >= 0; i--) {
                    int tmp = this.get(i).equals(Boolean.TRUE) ? 1 : 0;
                    if (((double) (i + 1) % 8 == 0.0) && (i != this.size() - 1)) {
                        sb.append(' ');
                    }
                    sb.append(tmp);
                }
                return sb.toString();
            }
     
            public String toString(int radix) {
                byte[] bytes = this.toByteArray();
                StringBuilder sb = new StringBuilder("[");
                for (byte b : bytes) {
                    sb.append(Integer.toString(b, radix));
                    sb.append(", ");
                }
                sb.replace(sb.length() - 2, sb.length(), "");
                sb.append("]");
     
                return sb.toString();
            }
     
            public byte[] toByteArray() {
                String[] splits = this.toString().split(" ");
                byte[] out = new byte[splits.length];
                for (int i = 0; i < splits.length; i++) {
                    out[i] = Byte.valueOf(splits[i], 2);
                }
     
                return out;
            }
    }

Discussions similaires

  1. manipulation de bits d'un byte
    Par orelero dans le forum Langage
    Réponses: 6
    Dernier message: 22/08/2008, 10h41
  2. Manipulation de bits/octets
    Par LionelD dans le forum C#
    Réponses: 3
    Dernier message: 29/07/2008, 18h22
  3. Question sur Bit / Byte / Octet
    Par Mr.joker dans le forum Protocoles
    Réponses: 6
    Dernier message: 29/10/2006, 20h04
  4. [Ada] Manipulation de "Bits"
    Par BoBy9 dans le forum Ada
    Réponses: 2
    Dernier message: 14/06/2006, 11h57
  5. Manipulation de bits
    Par Tsly dans le forum C++
    Réponses: 2
    Dernier message: 28/09/2005, 12h41

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo