console.writeline et du Système.out.println

Quelle est exactement la différence technique entre console.writeline et System.out.println?
Je sais que System.out.println écrit sur la sortie standard, mais n'est-ce pas la même chose que la console?

Je ne suis pas entièrement comprendre le la documentation pour console.writeline.

Voir stackoverflow.com/questions/2369731/...
également de la console.writeline n'est pas une méthode en java (il est .net)... mais je comprends ce que vous demandez 🙂

InformationsquelleAutor ziggy | 2010-10-23

io java

115

Voici les principales différences entre l'utilisation de System.out/.err/.en et System.console():
- System.console() retourne null si votre application n'est pas exécutée dans un terminal (bien que vous pouvez gérer cela dans votre application)
- System.console() fournit des méthodes pour lire le mot de passe sans écho caractères
- System.out et System.err utilisation de la plateforme par défaut l'encodage, alors que le Console de sortie de classe des méthodes d'utilisation de la console d'encodage
Ce dernier comportement peut ne pas être immédiatement évident, mais ce type de code peut démontrer la différence:
```
public class ConsoleDemo {
  public static void main(String[] args) {
    String[] data = { "\u250C\u2500\u2500\u2500\u2500\u2500\u2510", 
        "\u2502Hello\u2502",
        "\u2514\u2500\u2500\u2500\u2500\u2500\u2518" };
    for (String s : data) {
      System.out.println(s);
    }
    for (String s : data) {
      System.console().writer().println(s);
    }
  }
}
```
Sur mon Windows XP qui dispose d'un système de codage de windows-1252 et une console par défaut l'encodage de IBM850, ce code d'écriture:
```
???????
?Hello?
???????
┌─────┐
│Hello│
└─────┘
```
Notez que ce comportement dépend de la console de codage d'un codage différent du système de codage. C'est le comportement par défaut sur Windows pour un tas de raisons historiques.
- Vous pouvez obtenir un exemple de ne pas courir dans un terminal?
- si vous frappez exécuté à partir d'un IDE, ou si vous lancer un fichier exécutable jar à partir d'une interface graphique.
InformationsquelleAutor McDowell
14

Ils sont essentiellement de la même façon, si votre programme est exécuté à partir d'une invite de commandes et vous n'avez pas redirigés stdin ou stdout:
```
public class ConsoleTest {
    public static void main(String[] args) {
        System.out.println("Console is: " + System.console());
    }
}
```
résultats dans:
```
$ java ConsoleTest
Console is: java.io.Console@2747ee05
$ java ConsoleTest </dev/null
Console is: null
$ java ConsoleTest | cat
Console is: null
```
La raison Console est de fournir des fonctionnalités qui sont utiles dans le cas spécifique que vous êtes en cours d'exécution à partir d'un interactif en ligne de commande:
- mot de passe sécurisé entrée (dur de faire de la croix-plate-forme)
- de synchronisation (plusieurs threads peuvent invite pour l'entrée et la Console seront en file bien, alors que si vous avez utilisé le Système.in/out puis tous les invites apparaissent simultanément).
La remarque ci-dessus que la redirection même un des flux de résultats dans System.console() retour null; un autre irritation est qu'il n'y a souvent pas de Console objet disponible lorsque générés à partir d'un autre programme tel que Eclipse ou Maven.

InformationsquelleAutor SimonJ
6

D'abord, je suis peur que votre question contient une petite erreur. Il n'y a pas de méthode writeline dans la classe Console. Au lieu de la classe Console fournit la méthode de l'écrivain() qui retourne PrintWriter. Cette impression écrivain a println().

Maintenant, quelle est la différence entre
```
System.console().writer().println("hello from console");
```
et
```
System.out.println("hello system out");
```
Si vous exécutez votre application en ligne de commande je pense qu'il n'y a pas de différence. Mais si la console n'est pas disponible Système.console() renvoie la valeur null lorsque le Système.encore existe. Cela peut se produire si vous appelez votre demande et effectuer la redirection de la sortie standard vers un fichier.

Voici un exemple que j'ai déjà mises en œuvre.
```
import java.io.Console;


public class TestConsole {
    public static void main(String[] args) {
        Console console = System.console();
        System.out.println("console=" + console);
        console.writer().println("hello from console");
    }
}
```
Quand j'ai couru l'application à partir de l'invite de commande j'ai eu la suivante:
```
$ java TestConsole
console=java.io.Console@93dcd
hello from console
```
mais quand j'ai redirigé la sortie standard dans un fichier...
```
$ java TestConsole >/tmp/test
Exception in thread "main" java.lang.NullPointerException
        at TestConsole.main(TestConsole.java:8)
```
La ligne 8 est console.writer().println().

Voici le contenu de /tmp/test
```
console=null
```
J'espère que mes explications vous aider.
- À cause de code à apparaître comme des blocs de code, tiret à chaque ligne avec quatre espaces. (Je l'ai juste fait pour vous, si.)
- Il est, cependant, une Console.printf, et une Console.format, qui écrivent directement, sans avoir besoin d'extraire l'intervenant PrintWriter. Bizarre 🙂
InformationsquelleAutor AlexR
2

Il n'y a pas Console.writeline en Java. Ses dans .NET.

Console et standard ne sont pas les mêmes. Si vous lisez la Javadoc page, vous mentionné, vous verrez qu'une application peut avoir accès à une console uniquement si elle est appelée à partir de la ligne de commande et la sortie n'est pas redirigé, comme ce
```
java -jar MyApp.jar > MyApp.log
```
D'autres cas de ce genre sont couverts dans SimonJ de répondre, mais il a manqué le point qu'il n'y a pas de Console.writeline.
- Oui, j'ai pensé que ziggy du compilateur (ou à la Javadoc) pourrait faire ce travail pour moi 🙂
InformationsquelleAutor Nithesh Chandra

Vous devez vous connecter pour publier un commentaire.