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

avec Java Discussion :

String : Pivoter verticalement


Sujet :

avec Java

  1. #1
    Invité
    Invité(e)
    Par défaut String : Pivoter verticalement
    Bonjour ,

    Disons que j'ai un dessin horizontal dans un String



    *****************



    Est-ce possible avec une fonction , classe ou autres , de le transformer en :

    *

    *

    *

    *

    *

    *



    Le faire pivoter de l'horizontal au verticale ?

    Pour mon cas, il s'agit d'une figure géométrique



    Merci d'avance

  2. #2
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Janvier 2010
    Messages
    312
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Janvier 2010
    Messages : 312
    Points : 533
    Points
    533
    Par défaut
    Bonjour,

    Si ton but est juste d'effectuer une rotation d'un String tu peux utiliser Graphics2D avec les méthodes rotate() et drawString() comme dans cet exemple :

    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
     
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
     
    public class TestString extends JPanel implements ActionListener{
     
    	JTextField text = new JTextField(5);
     
    	public TestString() {
    		setPreferredSize(new Dimension(400,372));
    		text.setText("**********");
    	}
     
    	public static void main (String[] args) {
    		JFrame f = new JFrame();
    		TestString ts = new TestString();
    		JPanel panelNord = new JPanel();
    		JButton bouton = new JButton("Valider");
    		panelNord.add(ts.text);
    		bouton.addActionListener(ts);
    		panelNord.add(bouton);
    		f.setSize(400,400);
    		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		f.add(panelNord,BorderLayout.NORTH);
    		f.add(ts,BorderLayout.CENTER);
    		f.setVisible(true);
    	}
     
    	public void actionPerformed(ActionEvent e) { 
    			repaint();
    	}
     
    	public void paintComponent(Graphics g) {
    		Graphics2D g2 = (Graphics2D) g;
    		g2.clearRect(0,0,400,372);
    		g2.translate(100,100);
    		g2.rotate(Math.PI/2);
    		g2.drawString(text.getText(),0,0);
    	}
    }

  3. #3
    Invité
    Invité(e)
    Par défaut
    Salut , merci de ta réponse .

    J'ai en effet oublié de préciser que cela devait être sous console , donc pas de fenetre à part , ni l'implémentation d'autres choses .
    La méthode rotate suffit toute seule ?

  4. #4
    Membre actif
    Homme Profil pro
    Développeur Java / JEE
    Inscrit en
    Février 2008
    Messages
    185
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur Java / JEE

    Informations forums :
    Inscription : Février 2008
    Messages : 185
    Points : 293
    Points
    293
    Par défaut
    Bonjour,

    Il te faudra des retours à la ligne entre chaque "*". Tu peux mettre le caractère "\n" par exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    System.out.print("*\n*\n*\n*");
    Mathieu

  5. #5
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Janvier 2010
    Messages
    312
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Janvier 2010
    Messages : 312
    Points : 533
    Points
    533
    Par défaut
    Bonjour,

    Désolé, j'ai effectivement un peu interprété......

    C'est encore plus simple, il te suffit de passer en revue dans une boucle tous les caracteres de ta chaine et les afficher avec println() afin d'y inclure un retour à la ligne.

    Dans mon exemple tu peux rentrer une chaine comme argument de TestString et elle s'affiche à la verticale dans la console

    ex : java TestString coucou

    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
     
    public class TestString{
     
     
    	public static void main (String[] args) {
    		if (args.length > 0) {
    			String s = args[0];
    			for (int i=0; i<s.length();i++) {
    				System.out.println(s.charAt(i));
    			}
    		}
    		else {
    			System.out.println("Merci de rentrer une chaine");	
    		}
     
    	}
    }

  6. #6
    Invité
    Invité(e)
    Par défaut
    Salut :-)

    Merci de vos réponses . La chaine " *** " se met verticalement en effet .

    Cependant , comme je l'ai précisé au premier post , mon cas s'agit de figures géométriques , tel que celle ci :



    La chaine " **** " était un mauvais exemple de ma part , je m'en excuse .

    D'autres solutions sont possibles ? Car avec cette figure par exemple , cela ne marche pas du tout

  7. #7
    Modérateur

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

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    - Stocker la forme dans une matrice char[][]
    - Créer une autre matrice char[][] qui est une rotation de la première
    - Afficher cette nouvelle matrice.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  8. #8
    Invité
    Invité(e)
    Par défaut
    Bonjour ,

    Il y aurait moyen de trouver un tuto simple et clair pour faire ta solution ?
    La figure est un String .

  9. #9
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Janvier 2010
    Messages
    312
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Janvier 2010
    Messages : 312
    Points : 533
    Points
    533
    Par défaut
    bonjour,

    voici une application de ce que propose Thelvin :

    1- creation d'une méthode stringToMatrice(String) qui transforme le String en une matrice de char

    on calcule le nombre de lignes en utilisant split("\n") qui nous donne un tableau de lignes (lignes).

    Et le nombre de colonnes en calculant la String la plus longue du tableau de lignes précédemment acquis.

    on initialise cette matrice avec des ' ' afin qu'après la rotation il y ait des espaces au début

    Et on remplit la matrice en utilisant la méthode charAt sur le tableau de ligne précédent.

    2- création d'une méthode rotateMatrice(char[][]) qui effectue la rotation

    il suffit de remplacer matriceResultat[i][j] = matriceInitiale[j][i]

    3- creation d'une méthode afficherMatrice(char[][]) qui affiche la matrice à l'aide de 2 boucles imbriquées.

    4- En bonus, si besoin création d'une méthode matriceToString(char[][]) pour reconstruire un String depuis une matrice

    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
     
    public class TestString{
     
    	static String s = "*******************\n *****************\n  ***************\n   *************\n    ***********\n     *********\n      *******\n       *****\n        ***\n         *\n         *\n        ***\n       *****\n      *******\n     *********\n    ***********\n   *************\n  ***************\n *****************\n*******************";
     
    	public static void main (String[] args) {
    		System.out.println(s);
    		char[][] matrice = rotateMatrice(stringToMatrice(s));
                    //affichage de la matrice
    		afficherMatrice(matrice);
                   //affichage du string issu de la matrice
    		System.out.println(matriceToString(matrice));
     
    	}
     
    	public static char[][] stringToMatrice(String s) {
     
    		//nombre de lignes
    		String[] lignes = s.split("\n");
    		int nbLignes = lignes.length;
     
    		//nombre de colonnes
    		int nbColonnes = 0;
    		for (int i =0; i<nbLignes;i++) {
    			if (lignes[i].length() > nbColonnes)
    				nbColonnes = lignes[i].length();
    		}
     
    		//initialisation de la matrice avec des espaces
    		char[][] resultat = new char[nbLignes][nbColonnes];
    		for (int i=0; i<nbLignes;i++) {
    			for (int j=0;j<nbColonnes;j++) {
    				resultat[i][j] = ' ';
    			}
    		}
    		//remplissage de la matrice
    		for (int i=0; i < nbLignes;i++) {
    			for (int j = 0;j<lignes[i].length();j++) {
    				resultat[i][j] = lignes[i].charAt(j);
    			}
    		}
    		return resultat;
    	}
     
    	public static char[][] rotateMatrice(char[][] mat) {
    		int nbLignes = mat.length;
    		int nbColonnes = mat[0].length;
    		char[][] resultat = new char[nbColonnes][nbLignes];
    		for (int i = 0; i< nbColonnes;i++) {
    			for (int j=0; j<nbLignes;j++) {
    				resultat[i][j] = mat[j][i];	
    			}
    		}
    		return resultat;
    	}
     
    	public static void afficherMatrice(char[][] mat) {
    		int nbLignes = mat.length;
    		int nbColonnes = mat[0].length;
    		for (int i=0;i< nbLignes;i++) {
    			for (int j=0; j< nbColonnes;j++) {
    				System.out.print(mat[i][j]);	
    			}
    			System.out.println();
    		}
    	}
     
    	public static String matriceToString(char[][] mat) {
    		int nbLignes = mat.length;
    		int nbColonnes = mat[0].length;
    		String resultat = "";
    		for (int i=0;i< nbLignes;i++) {
    			for (int j=0; j< nbColonnes;j++) {
    				resultat = resultat + mat[i][j];	
    			}
    			if (i< nbLignes - 1 )  resultat=resultat + "\n";
    		}
    		return resultat;
    	}
    }

  10. #10
    Invité
    Invité(e)
    Par défaut
    Bonsoir

    Merci de vos réponses . Cela correspond à mes attentes .

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. instruction PIVOT pour string
    Par Poussy-Puce dans le forum Langage SQL
    Réponses: 5
    Dernier message: 16/06/2010, 19h15
  2. éliminer un caractere d'un string
    Par no-vice dans le forum Langage
    Réponses: 5
    Dernier message: 09/08/2002, 15h55
  3. URGENT: retour de string
    Par Pinggui dans le forum CORBA
    Réponses: 4
    Dernier message: 15/07/2002, 10h47
  4. Réponses: 2
    Dernier message: 05/06/2002, 13h29
  5. String Grid et choix d'une couleur pour une ligne
    Par Gigottine dans le forum C++Builder
    Réponses: 12
    Dernier message: 17/05/2002, 16h23

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