Chaîne multiligne Java
En venant de Perl, il me manque le moyen "ici-document" de créer une chaîne multiligne dans le code source:
$string = <<"EOF" # create a three-line string
text
text
text
EOF
En Java, je dois avoir des guillemets encombrants et des signes plus sur chaque ligne pour concaténer ma chaîne multiligne à partir de zéro.
Quelles sont les meilleures alternatives? Définir ma chaîne dans un fichier de propriétés?
Edit : Deux réponses disent que StringBuilder.append () est préférable à la notation plus. Quelqu'un pourrait-il expliquer pourquoi ils le pensent? Cela ne me semble pas préférable du tout. Je cherche un moyen de contourner le fait que les chaînes multilignes ne sont pas une construction de langage de première classe, ce qui signifie que je ne souhaite absolument pas remplacer une construction de langage de première classe (concaténation de chaîne avec plus) par des appels de méthode.
Edit : Pour clarifier ma question, je ne suis pas du tout préoccupé par les performances. Je suis préoccupé par la maintenabilité et les problèmes de conception.
Stephen Colebourne a créé une proposition pour l'ajout de chaînes multilignes dans Java 7.
En outre, Groovy prend déjà en charge les chaînes multi-lignes .
Il semble que vous souhaitiez créer un littéral multiligne, qui n'existe pas en Java.
Votre meilleure alternative sera les chaînes qui sont simplement + 'd ensemble. Certaines autres options mentionnées par les utilisateurs (StringBuilder, String.format, String.join) ne seraient préférables que si vous utilisiez un tableau de chaînes.
Considère ceci:
String s = "It was the best of times, it was the worst of times,\n"
+ "it was the age of wisdom, it was the age of foolishness,\n"
+ "it was the Epoch of belief, it was the Epoch of incredulity,\n"
+ "it was the season of Light, it was the season of Darkness,\n"
+ "it was the spring of hope, it was the winter of despair,\n"
+ "we had everything before us, we had nothing before us";
Versus StringBuilder:
String s = new StringBuilder()
.append("It was the best of times, it was the worst of times,\n")
.append("it was the age of wisdom, it was the age of foolishness,\n")
.append("it was the Epoch of belief, it was the Epoch of incredulity,\n")
.append("it was the season of Light, it was the season of Darkness,\n")
.append("it was the spring of hope, it was the winter of despair,\n")
.append("we had everything before us, we had nothing before us")
.toString();
Versus String.format():
String s = String.format("%s\n%s\n%s\n%s\n%s\n%s"
, "It was the best of times, it was the worst of times,"
, "it was the age of wisdom, it was the age of foolishness,"
, "it was the Epoch of belief, it was the Epoch of incredulity,"
, "it was the season of Light, it was the season of Darkness,"
, "it was the spring of hope, it was the winter of despair,"
, "we had everything before us, we had nothing before us"
);
Versus Java8 String.join() :
String s = String.join("\n"
, "It was the best of times, it was the worst of times,"
, "it was the age of wisdom, it was the age of foolishness,"
, "it was the Epoch of belief, it was the Epoch of incredulity,"
, "it was the season of Light, it was the season of Darkness,"
, "it was the spring of hope, it was the winter of despair,"
, "we had everything before us, we had nothing before us"
);
Si vous voulez la nouvelle ligne pour votre système particulier, vous devez utiliser System.getProperty("line.separator") ou vous pouvez utiliser %n dans String.format.
Une autre option consiste à placer la ressource dans un fichier texte et à simplement lire le contenu de ce fichier. Cela serait préférable pour les très grandes chaînes afin d'éviter de gonfler inutilement vos fichiers de classe.
Dans Eclipse, si vous activez l'option "Échapper du texte lors du collage dans un littéral de chaîne" (dans Préférences> Java> Editeur> Saisie) et collez une chaîne multiligne entre guillemets, le code " et \n" + sera automatiquement ajouté.
String str = "paste your text here";
Ceci est un vieux fil, mais une nouvelle solution assez élégante (avec seulement 4 peut-être 3 petits inconvénients) consiste à utiliser une annotation personnalisée.
Vérifier: http://www.adrianwalker.org/2011/12/Java-multiline-string.html
Un projet inspiré de ce travail est hébergé sur GitHub:
https://github.com/benelog/multiline
Exemple de code Java:
import org.adrianwalker.multilinestring.Multiline;
...
public final class MultilineStringUsage {
/**
<html>
<head/>
<body>
<p>
Hello<br/>
Multiline<br/>
World<br/>
</p>
</body>
</html>
*/
@Multiline
private static String html;
public static void main(final String[] args) {
System.out.println(html);
}
}
Les inconvénients sont
- que vous devez activer l'annotation (fournie) correspondante processeur.
- cette variable de chaîne ne peut pas être définie en tant que variable locale Vérifier Projet de littéraux bruts en chaîne où vous pouvez définir des variables en tant que variables locales
- cette chaîne ne peut pas contenir d'autres variables, comme dans Visual Basic .Net avec un littéral XML (
<%= variable %>) :-) - ce littéral de chaîne est délimité par un commentaire JavaDoc (/ **)
Et vous devrez probablement configurer Eclipse/Intellij-Idea pour ne pas reformater automatiquement vos commentaires Javadoc.
On peut trouver cela bizarre (les commentaires Javadoc ne sont pas conçus pour incorporer autre chose que des commentaires), mais comme ce manque de chaîne multiligne en Java est vraiment gênant au final, je trouve que c'est la moins mauvaise solution.
Une autre option peut être de stocker de longues chaînes dans un fichier externe et de lire le fichier dans une chaîne.
C’est quelque chose que vous devriez utiliser {jamais} _ sans penser à ce qu’il fait. Mais pour les scripts uniques, je l'ai utilisé avec un grand succès:
Exemple:
System.out.println(S(/*
This is a CRAZY " ' ' " multiline string with all sorts of strange
characters!
*/));
Code:
// From: http://blog.efftinge.de/2008/10/multi-line-string-literals-in-Java.html
// Takes a comment (/**/) and turns everything inside the comment to a string that is returned from S()
public static String S() {
StackTraceElement element = new RuntimeException().getStackTrace()[1];
String name = element.getClassName().replace('.', '/') + ".Java";
StringBuilder sb = new StringBuilder();
String line = null;
InputStream in = classLoader.getResourceAsStream(name);
String s = convertStreamToString(in, element.getLineNumber());
return s.substring(s.indexOf("/*")+2, s.indexOf("*/"));
}
// From http://www.kodejava.org/examples/266.html
private static String convertStreamToString(InputStream is, int lineNum) {
/*
* To convert the InputStream to String we use the BufferedReader.readLine()
* method. We iterate until the BufferedReader return null which means
* there's no more data to read. Each line will appended to a StringBuilder
* and returned as String.
*/
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
String line = null; int i = 1;
try {
while ((line = reader.readLine()) != null) {
if (i++ >= lineNum) {
sb.append(line + "\n");
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return sb.toString();
}
String.join
Java 8 a ajouté une nouvelle méthode statique à Java.lang.String qui offre une alternative légèrement meilleure:
String.join(
CharSequence delimiter ,
CharSequence... elements
)
En l'utilisant:
String s = String.join(
System.getProperty("line.separator"),
"First line.",
"Second line.",
"The rest.",
"And the last!"
);
Si vous définissez vos chaînes dans un fichier de propriétés, cela aura l'air bien pire. IIRC, ça va ressembler à:
string:text\u000atext\u000atext\u000a
En règle générale, il est raisonnable de ne pas intégrer de grandes chaînes à la source. Vous voudrez peut-être les charger en tant que ressources, peut-être en XML ou en un format de texte lisible. Les fichiers texte peuvent être lus au moment de l'exécution ou compilés dans une source Java. Si vous finissez par les placer dans le source, je suggère de placer le + au début et d’omettre les nouvelles lignes inutiles:
final String text = ""
+"text "
+"text "
+"text"
;
Si vous avez de nouvelles lignes, vous voudrez peut-être une méthode de jointure ou de formatage:
final String text = join("\r\n"
,"text"
,"text"
,"text"
);
Les avantages sont convertis en StringBuilder.append, sauf lorsque les deux chaînes sont des constantes afin que le compilateur puisse les combiner au moment de la compilation. Du moins, c'est ce qui se passe dans le compilateur de Sun, et je suppose que la plupart sinon tous les autres compilateurs feraient de même.
Alors:
String a="Hello";
String b="Goodbye";
String c=a+b;
génère normalement exactement le même code que:
String a="Hello";
String b="Goodbye":
StringBuilder temp=new StringBuilder();
temp.append(a).append(b);
String c=temp.toString();
D'autre part:
String c="Hello"+"Goodbye";
est le même que:
String c="HelloGoodbye";
Autrement dit, il n'y a aucune pénalité à rompre les littéraux de chaîne sur plusieurs lignes avec des signes plus pour une meilleure lisibilité.
Dans l’IntelliJ IDE, il vous suffit de taper:
""
Placez ensuite votre curseur entre les guillemets et collez votre chaîne. Le IDE le développera en plusieurs lignes concaténées.
String newline = System.getProperty ("line.separator");
string1 + newline + string2 + newline + string3
Mais la meilleure alternative est d’utiliser String.format
String multilineString = String.format("%s\n%s\n%s\n",line1,line2,line3);
Malheureusement, Java n’a pas de littéraux multilignes. Vous devez concaténer les littéraux de chaîne (+ ou StringBuilder étant les deux approches les plus courantes) ou lire la chaîne à partir d'un fichier séparé.
Pour les grands littéraux de chaînes multilignes, je serais enclin à utiliser un fichier séparé et à le lire en utilisant getResourceAsStream() (une méthode de la classe Class). Cela facilite la recherche du fichier car vous n'avez pas à vous soucier du répertoire actuel par rapport à l'emplacement d'installation de votre code. Cela facilite également l’emballage, car vous pouvez réellement stocker le fichier dans votre fichier jar.
Supposons que vous soyez dans une classe appelée Foo. Faites juste quelque chose comme ça:
Reader r = new InputStreamReader(Foo.class.getResourceAsStream("filename"), "UTF-8");
String s = Utils.readAll(r);
Autre inconvénient, Java n’a pas de méthode standard "lire tout le texte de ce Reader dans une chaîne". C'est assez facile à écrire quand même:
public static String readAll(Reader input) {
StringBuilder sb = new StringBuilder();
char[] buffer = new char[4096];
int charsRead;
while ((charsRead = input.read(buffer)) >= 0) {
sb.append(buffer, 0, charsRead);
}
input.close();
return sb.toString();
}
Vous pouvez utiliser scala-code, qui est compatible avec Java, et permet les chaînes multilignes incluses avec "" ":
package foobar
object SWrap {
def bar = """John said: "This is
a test
a bloody test,
my dear." and closed the door."""
}
(notez les guillemets à l'intérieur de la chaîne) et de Java:
String s2 = foobar.SWrap.bar ();
Que ce soit plus confortable ...?
Une autre approche, si vous manipulez souvent un texte long, qui devrait être placé dans votre code source, pourrait être un script, qui extrait le texte d'un fichier externe et l'enveloppe comme une chaîne multiligne Java, comme ceci:
sed '1s/^/String s = \"/;2,$s/^/\t+ "/;2,$s/$/"/' file > file.Java
afin que vous puissiez le copier-coller facilement dans votre source.
Puisque Java ne supporte pas (encore) nativement les chaînes multilignes, la seule façon pour le moment est de les pirater en utilisant l’une des techniques susmentionnées. J'ai construit le script Python suivant en utilisant certaines des astuces mentionnées ci-dessus:
import sys
import string
import os
print 'new String('
for line in sys.stdin:
one = string.replace(line, '"', '\\"').rstrip(os.linesep)
print ' + "' + one + ' "'
print ')'
Mettez cela dans un fichier nommé javastringify.py et votre chaîne dans un fichier mystring.txt et exécutez-le comme suit:
cat mystring.txt | python javastringify.py
Vous pouvez ensuite copier le résultat et le coller dans votre éditeur.
Modifiez-le si nécessaire pour gérer des cas particuliers, mais cela fonctionne pour mes besoins. J'espère que cela t'aides!
JEP 326: Littéraux de chaîne bruts implémentera des chaînes multilignes pour pouvoir écrire quelque chose comme
String s = `
text
text
text
`;
Vous pouvez concaténer vos annexes dans une méthode distincte telle que:
public static String multilineString(String... lines){
StringBuilder sb = new StringBuilder();
for(String s : lines){
sb.append(s);
sb.append ('\n');
}
return sb.toString();
}
Dans tous les cas, préférez StringBuilder à la notation plus.
En fait, ce qui suit est la mise en œuvre la plus propre que j'ai vue jusqu'à présent. Il utilise une annotation pour convertir un commentaire en variable chaîne ...
/**
<html>
<head/>
<body>
<p>
Hello<br/>
Multiline<br/>
World<br/>
</p>
</body>
</html>
*/
@Multiline
private static String html;
Ainsi, le résultat final est que la variable html contient la chaîne multiligne. Pas de guillemets, pas de points positifs, pas de virgules, juste de la chaîne pure.
Cette solution est disponible à l’URL suivante ... http://www.adrianwalker.org/2011/12/Java-multiline-string.html
J'espère que cela pourra aider!
Voir Java Stringfier . Transforme votre texte en un bloc Java StringBuilder échappé si nécessaire.
Une alternative que je n'ai pas encore vue comme réponse est le Java.io.PrintWriter .
StringWriter stringWriter = new StringWriter();
PrintWriter writer = new PrintWriter(stringWriter);
writer.println("It was the best of times, it was the worst of times");
writer.println("it was the age of wisdom, it was the age of foolishness,");
writer.println("it was the Epoch of belief, it was the Epoch of incredulity,");
writer.println("it was the season of Light, it was the season of Darkness,");
writer.println("it was the spring of hope, it was the winter of despair,");
writer.println("we had everything before us, we had nothing before us");
String string = stringWriter.toString();
De plus, le fait que Java.io.BufferedWriter a une méthode newLine() n'est pas mentionné.
import org.Apache.commons.lang3.StringUtils;
String multiline = StringUtils.join(new String[] {
"It was the best of times, it was the worst of times ",
"it was the age of wisdom, it was the age of foolishness",
"it was the Epoch of belief, it was the Epoch of incredulity",
"it was the season of Light, it was the season of Darkness",
"it was the spring of hope, it was the winter of despair",
"we had everything before us, we had nothing before us"
}, "\n");
Si vous aimez autant que moi la goyave de Google, elle peut donner une représentation assez nette et un moyen simple et agréable de ne pas coder en dur vos caractères de nouvelle ligne:
String out = Joiner.on(newline).join(ImmutableList.of(
"line1",
"line2",
"line3"));
Une solution assez efficace et indépendante de la plate-forme utiliserait la propriété système pour les séparateurs de ligne et la classe StringBuilder pour créer des chaînes:
String separator = System.getProperty("line.separator");
String[] lines = {"Line 1", "Line 2" /*, ... */};
StringBuilder builder = new StringBuilder(lines[0]);
for (int i = 1; i < lines.length(); i++) {
builder.append(separator).append(lines[i]);
}
String multiLine = builder.toString();
Définir ma chaîne dans un fichier de propriétés?
Les chaînes multilignes ne sont pas autorisées dans les fichiers de propriétés. Vous pouvez utiliser\n dans les fichiers de propriétés, mais je ne pense pas que ce soit vraiment une solution pour vous.
Utilisez Properties.loadFromXML(InputStream). Il n'y a pas besoin de bibliothèques externes.
Mieux qu’un code en désordre (car la maintenance et la conception sont votre préoccupation), il est préférable de ne pas utiliser de longues chaînes .
Commencez par lire les propriétés xml:
InputStream fileIS = YourClass.class.getResourceAsStream("MultiLine.xml");
Properties prop = new Properies();
prop.loadFromXML(fileIS);
alors vous pouvez utiliser votre chaîne multiligne d’une manière plus maintenable ...
static final String UNIQUE_MEANINGFUL_KEY = "Super Duper UNIQUE Key";
prop.getProperty(UNIQUE_MEANINGFUL_KEY) // "\n MEGA\n LONG\n..."
MultiLine.xml` est situé dans le même dossier YourClass:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://Java.Sun.com/dtd/properties.dtd">
<properties>
<entry key="Super Duper UNIQUE Key">
MEGA
LONG
MULTILINE
</entry>
</properties>
PS .: Vous pouvez utiliser <![CDATA[" ... "]]> pour une chaîne semblable à xml.
Une bonne option.
import static some.Util.*;
public class Java {
public static void main(String[] args) {
String sql = $(
"Select * from Java",
"join some on ",
"group by"
);
System.out.println(sql);
}
}
public class Util {
public static String $(String ...sql){
return String.join(System.getProperty("line.separator"),sql);
}
}
Lorsqu'une longue série de + est utilisée, un seul StringBuilder est créé, à moins que la chaîne ne soit déterminée lors de la compilation, auquel cas aucun StringBuilder n'est utilisé!
La seule fois où StringBuilder est plus efficace, c’est lorsque plusieurs instructions sont utilisées pour construire la chaîne.
String a = "a\n";
String b = "b\n";
String c = "c\n";
String d = "d\n";
String abcd = a + b + c + d;
System.out.println(abcd);
String abcd2 = "a\n" +
"b\n" +
"c\n" +
"d\n";
System.out.println(abcd2);
Remarque: Un seul StringBuilder est créé.
Code:
0: ldc #2; //String a\n
2: astore_1
3: ldc #3; //String b\n
5: astore_2
6: ldc #4; //String c\n
8: astore_3
9: ldc #5; //String d\n
11: astore 4
13: new #6; //class Java/lang/StringBuilder
16: dup
17: invokespecial #7; //Method Java/lang/StringBuilder."<init>":()V
20: aload_1
21: invokevirtual #8; //Method Java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
24: aload_2
25: invokevirtual #8; //Method Java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: aload_3
29: invokevirtual #8; //Method Java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
32: aload 4
34: invokevirtual #8; //Method Java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
37: invokevirtual #9; //Method Java/lang/StringBuilder.toString:()Ljava/lang/String;
40: astore 5
42: getstatic #10; //Field Java/lang/System.out:Ljava/io/PrintStream;
45: aload 5
47: invokevirtual #11; //Method Java/io/PrintStream.println:(Ljava/lang/String;)V
50: ldc #12; //String a\nb\nc\nd\n
52: astore 6
54: getstatic #10; //Field Java/lang/System.out:Ljava/io/PrintStream;
57: aload 6
59: invokevirtual #11; //Method Java/io/PrintStream.println:(Ljava/lang/String;)V
62: return
Pour clarifier davantage ma question, la performance ne m'inquiète pas du tout. Je suis préoccupé par la maintenabilité et les problèmes de conception.
Rendez-le aussi clair et simple que possible.
Je suggère d'utiliser un utilitaire tel que suggéré par ThomasP, puis de le lier à votre processus de construction. Un fichier externe est toujours présent pour contenir le texte, mais le fichier n'est pas lu au moment de l'exécution . Le workflow est alors:
- Construire un utilitaire 'fichier texte en code Java' et vérifier dans le contrôle de version
- À chaque génération, exécutez l'utilitaire sur le fichier de ressources pour créer une source Java révisée.
- La source Java contient un en-tête tel que
class TextBlock {...suivi d'une chaîne statique générée automatiquement à partir du fichier de ressources. - Construisez le fichier Java généré avec le reste de votre code
Le dernier modèle Java a des optimisations pour + avec des chaînes constantes, utilise un StringBuffer en arrière-plan, afin que vous ne vouliez pas encombrer votre code avec.
Cela indique un oubli de la part de Java, à savoir qu’il ne ressemble pas à la norme ANSI C dans la concaténation automatique des chaînes entre guillemets doubles avec uniquement un espace entre elles,
const char usage = "\n"
"Usage: xxxx <options>\n"
"\n"
"Removes your options as designated by the required parameter <options>,\n"
"which must be one of the following strings:\n"
" love\n"
" sex\n"
" drugs\n"
" rockandroll\n"
"\n" ;
J'aimerais avoir une constante de tableau de caractères multiligne où les sauts de ligne incorporés sont respectés, afin de pouvoir présenter le bloc sans aucune image de fond, par exemple:
String Query = "
SELECT
some_column,
another column
FROM
one_table a
JOIN
another_table b
ON a.id = b.id
AND a.role_code = b.role_code
WHERE a.dept = 'sales'
AND b.sales_quote > 1000
Order BY 1, 2
" ;
Pour obtenir cela, il faut battre les dieux de Java.
Un petit truc. En utilisant ceci j'injecte du javascript dans une page HTML créée dynamiquement
StringBuilder builder = new StringBuilder();
public String getString()
{
return builder.toString();
}
private DropdownContent _(String a)
{
builder.append(a);
return this;
}
public String funct_showhide()
{
return
_("function slidedown_showHide(boxId)").
_("{").
_("if(!slidedown_direction[boxId])slidedown_direction[boxId] = 1;").
_("if(!slideDownInitHeight[boxId])slideDownInitHeight[boxId] = 0;").
_("if(slideDownInitHeight[boxId]==0)slidedown_direction[boxId]=slidedownSpeed; ").
_("else slidedown_direction[boxId] = slidedownSpeed*-1;").
_("slidedownContentBox = document.getElementById(boxId);").
_("var subDivs = slidedownContentBox.getElementsByTagName('DIV');").
_("for(var no=0;no<subDivs.length;no++){").
_(" if(subDivs[no].className=='dhtmlgoodies_content')slidedownContent = subDivs[no];").
_("}").
_("contentHeight = slidedownContent.offsetHeight;").
_("slidedownContentBox.style.visibility='visible';").
_("slidedownActive = true;").
_("slidedown_showHide_start(slidedownContentBox,slidedownContent);").
_("}").getString();
}
Je sais que c’est une vieille question, mais pour les développeurs intéressés, les littéraux à plusieurs lignes seront en # Java12.
http://mail.openjdk.Java.net/pipermail/amber-dev/2018-July/003254.html
J'utilise parfois une classe groovy parallèle juste pour agir comme un sac de cordes
La classe Java ici
public class Test {
public static void main(String[] args) {
System.out.println(TestStrings.json1);
// consume .. parse json
}
}
Et les chaînes multilignes convoitées ici dans TestStrings.groovy
class TestStrings {
public static String json1 = """
{
"name": "Fakeer's Json",
"age":100,
"messages":["msg 1","msg 2","msg 3"]
}""";
}
Bien sûr, cela ne concerne que les chaînes statiques. Si je dois insérer des variables dans le texte, je changerai tout le fichier en groovy. Il suffit de maintenir des pratiques de dactylographie puissantes et cela peut être retiré.
Je vois au moins un cas dans lequel il convient d'éviter d'utiliser des fichiers externes pour les chaînes longues: si ces chaînes sont des valeurs attendues dans un fichier de test unitaire, car je pense que les tests doivent toujours être écrits de manière à compter sur une ressource externe.
Avec JDK/12 early access build # 12 , vous pouvez désormais utiliser des chaînes multilignes en Java comme suit:
String multiLine = `First line
Second line with indentation
Third line
and so on...`; // the formatting as desired
System.out.println(multiLine);
et le résultat est le suivant:
First line Second line with indentation Third line and so on...
Cela peut sembler un peu fou, mais comme les heredocs sont un sucre syntaxique sur des déclarations d'une ligne sans les sauts de ligne, il est possible d'écrire des fichiers de prétraitement pour Java qui les transformeraient en une seule ligne lors du prétraitement.
Cela nécessiterait l'écriture de plugins appropriés pour le prétraitement des fichiers avant la phase de compilation (pour ant/maven build) et d'un plugin pour l'EDI.
D'un point de vue idéologique, rien ne diffère de f.g. "génériques", c’est aussi une sorte de sucre syntaxique prétraité pour la coulée.
Cependant, cela demande beaucoup de travail, je voudrais donc utiliser chez vous des fichiers .properties.
Utiliser cette bibliothèque
https://github.com/alessio-santacroce/multiline-string-literals
il est possible d'écrire des choses comme ça
System.out.println(newString(/*
Wow, we finally have
multiline strings in
Java! HOOO!
*/));
Très agréable et facile, mais ne fonctionne que pour les tests unitaires
Je me suis un peu ennuyé de lire que la syntaxe multiligne est en effet prévue pour jdk7 (après combien de décennies d’existence de Java?). Bizarrement, il n’existe pas encore de fonction readAll () pour lire le contenu complet d’un fichier (à partir de jdk7, hein), le code ci-dessous lit donc des lignes simples.
/*
MakeMultiline v1.0 (2010) - Libre d’utiliser et de copier .
Petit gadget pour transformer des blobs de texte en un seul littéral de chaîne Java
(fait le fractionnement en lignes, en ajoutant\n à chaque extrémité et en mettant
entre guillemets). Est-ce que les guillemets d'échappement rencontrés dans le blob de texte .
Utile pour travailler sur la syntaxe manquante des chaînes multilignes en Java
avant jdk7. Utiliser avec:
Java MakeMultiline ""
ou
Java MakeMultiline "" mon fichier texte.txt
*/
Importer Java.io. *;
Classe MakeMultiline {
public static void main (String [] args) {
essayez {
// args [0]: indent
// args [1]: nom du fichier à lire (facultatif; stdin s'il n'est pas indiqué)
// Attention au nombre de nouvelles lignes à la fin lorsque vous utilisez stdin!
Indentation de chaîne = (args.length> 0? Args [0]: "");
FileReader fr = null; BufferedReader br;
if (args.length> 1)
{fr = new FileReader (args [1]); br = new BufferedReader (fr); }
autre
{br = new BufferedReader (new InputStreamReader (System.in)); }
String s; String res = "";
while ((s = br.readLine ())! = null) {
if (res.length ()> 0) res + = "+\n";
res + = indent + "\" "+ s.replace ("\"", "\\\" ") +" \\ n\"";
}
br.close (); if (fr! = null) fr.close ();
System.out.println (res + ";");
}
capture (exception e) {
System.out.println ("Exception:" + e);
}
}
}
C'était la solution la plus rapide pour moi. (2010-01-27)
Une option simple consiste à éditer votre code Java avec un éditeur tel que SciTE ( http://www.scintilla.org/SciTEDownload.html ), ce qui vous permet d’enrouler le texte de sorte que les chaînes longues soient facilement visualisées et lisibles. édité. Si vous avez besoin de caractères d'échappement, il vous suffit de les insérer. En désactivant l'option d'emballage, vous pouvez vérifier que votre chaîne n'est en réalité qu'une longue chaîne d'une seule ligne. Mais bien sûr, le compilateur vous dira aussi si ce n'est pas le cas.
Que ce soit Eclipse ou NetBeans prend en charge le retour à la ligne dans un éditeur que je ne connais pas, car ils ont tellement d'options. Mais sinon, ce serait une bonne chose à ajouter.
Le seul moyen que je connaisse est de concaténer plusieurs lignes avec des signes plus