Liste verschwenderisch kreativer "Hello World" -Ausgabemethoden (Java)

Überblick

Wenn Sie anfangen, eine Sprache zu lernen, gibt das erste Programm, das Sie erstellen, normalerweise "Hello World" aus. Im Fall von Java lautet der Code wie folgt.

HelloWorld.java

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello World");
	}
}

Möglicherweise gibt es jedoch eine bessere Ausgabemethode. Diesmal möchte ich verschiedene Dinge ausprobieren.

Programmbeispiel

Hexadezimal angegeben

Geben Sie jedes Zeichen in Unicode an.

HelloWorld.java

public class HelloWorld {
	public static void main(String[] args) {
		String helloWorld = new String("\u0048" + 
				"\u0065" + 
				"\u006c" + 
				"\u006c" + 
				"\u006f" + 
				"\u0020" + 
				"\u0057" + 
				"\u006f" + 
				"\u0072" + 
				"\u006c" + 
				"\u0064");
		System.out.println(helloWorld);
	}
}

Ausführungsergebnis: Hello World

In binär angegeben

Geben Sie zuerst die Zeichen in Binärform an, konvertieren Sie sie in Hexadezimalzahlen, konvertieren Sie sie dann in Zeichen und geben Sie sie aus.

HelloWorld.java

public class HelloWorld {
	public static void main(String[] args) {
		//Halten Sie die Binärzahl
		String[] helloWorldLetters = {"1001000",
				"1100101",
				"1101100",
				"1101100",
				"1101111",
				"100000",
				"1010111",
				"1101111",
				"1110010",
				"1101100",
				"1100100"};
		
		//Konvertieren Sie das obige Array in hexadezimal. Geben Sie das Konvertierungsergebnis in die Variable "line" ein.
		String line = "";
		for (String helloWorldLetter:helloWorldLetters) {
			int decimal = Integer.parseInt(helloWorldLetter, 2);
			//Konvertieren Sie Binär in Hexadezimal
			String hex = Integer.toHexString(decimal);
			//Hexadezimal in Unicode konvertieren
			char letter = (char)Integer.parseInt(hex,16);
			line += letter;
		}
			
		String helloWorld = new String(line);
		System.out.println(helloWorld);
	}
}

Ausführungsergebnis: Hello World

Die Erstellungsprozesse "Hallo" und "Welt" werden parallel ausgeführt und ausgeführt

Erstellen Sie Hello und World gleichzeitig mithilfe der Thread-Verarbeitung. Warten Sie, bis die Verarbeitung abgeschlossen ist, und geben Sie sie aus. Wenn es ausführbar ist, kann es keinen Rückgabewert haben. Implementieren Sie es daher mit Callable. Hier ist zunächst der Code, der den Thread aufruft.

HelloWorld.java

package HelloWorld;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class HelloWorld {

	public static void main(String[] args) {
		//Variable zum Speichern des Ergebnisses
		String helloWorld;
		
		//Thread erstellen
		ExecutorService service = Executors.newFixedThreadPool(2);
		Future<String> future1 = service.submit(new HelloWorldCallable(0));
		Future<String> future2 = service.submit(new HelloWorldCallable(1));
		try {
			//Kombinieren Sie die zurückgegebenen Werte zu einem
			helloWorld = future1.get() + future2.get();
			System.out.println(helloWorld);
		}catch(Exception e) {
			System.out.println(e.getMessage());
		}
	}
}

Hier ist der Code auf der aufgerufenen Seite.

HelloWorldCallable.java

package HelloWorld;

import java.util.concurrent.Callable;

public class HelloWorldCallable implements Callable<String>{
	//Behalten Sie bei, welche Nummer angerufen wurde
	private int num;
	
	public HelloWorldCallable(int num) {
		this.num = num;
	}
	
	public String call() {
		if(this.num == 0) {
			return "Hello ";
		}else {
			return "World";
		}
	}
}

Ausführungsergebnis Hello World

Zeichen für Thread für Thread-Verarbeitung erstellt

Im obigen Beispiel ist es nur in "Hallo" und "Welt" unterteilt, aber auf jeden Fall werde ich versuchen, sie für jedes Zeichen zu trennen.

HelloWorld.java

package HelloWorld;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class HelloWorld {

	public static void main(String[] args) {
		//Variable zum Speichern des Ergebnisses
		String helloWorld = "";
		//Speichern Sie die Ergebnisse von Threads
		List<Future<String>> futures = new ArrayList<Future<String>>();
		
		//Thread erstellen
		ExecutorService service = Executors.newFixedThreadPool(10);
		for(int i = 0; i < 11; i++) {
			futures.add(service.submit(new HelloWorldCallable(i)));
		}
		try {
			for (Future<String> future:futures) {
				if(future.isDone()) {
					helloWorld += future.get();
				}
			}
			System.out.println(helloWorld);
		}catch(Exception e) {
			System.out.println(e.getMessage());
		}
	}
}

HelloWorldCallable.java

package HelloWorld;

import java.util.concurrent.Callable;

public class HelloWorldCallable implements Callable<String>{
	private static String[] message = {"H","e","l","l","o"," ","W","o","r","l","d"};
	//Behalten Sie bei, welche Nummer angerufen wurde
	private int num;
	
	public HelloWorldCallable(int num) {
		this.num = num;
	}
	
	public String call() {
		return message[num];
	}

}

Ausführungsergebnis: Hello World Die statische Variable der HelloWorldCallable-Klasse hat etwas, das fast "Hello World" ähnelt, aber keine Sorge.

Scraping und Ausgabe von "Hello World" aus dem Web

Die Zeichen stammen aus dem Titel dieser Seite der japanischen Version von Wikipedia.

HelloWorld.java

import java.util.List;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class HelloWorld {
	public static void main(String[] args) {
    	System.setProperty("webdriver.chrome.driver", "Wo sich der Chromtreiber befindet");
    	WebDriver driver = new ChromeDriver();

    	//Website, um Informationen zu erhalten
    	String url = "https://ja.wikipedia.org/wiki/Hello_world";
    	//HTML-Element, das die Informationen enthält, die Sie erhalten möchten (diesmal den Klassennamen des Wikipedia-Titels)
    	String target = "firstHeading";
    	
    	driver.get(url);
    	//Es können mehrere Ergebnisse erzielt werden, da dies durch den Klassennamen angegeben wird.
    	List<WebElement> values = driver.findElements(By.className(target)); 
    	for (WebElement t : values){
    	    String value = t.getText();
    	    //Wenn es so bleibt wie es ist, wird "Hallo Welt" ausgegeben, also konvertiere "w" in Großbuchstaben.
    	    String str = value.substring(0, 6)
    	    		+ value.substring(6, 7).toUpperCase()
    	    		+ value.substring(7);
    	    System.out.println(str);
    	}
	}
}

Ausführungsergebnis: Hello World

Zeichen für Zeichen aus dem Web schaben und ausgeben

Im obigen Beispiel werden alle Zeichenketten von einer Site übernommen. Hier ist jedoch eine Methode, mit der jedes Zeichen ohne solche Leichtigkeit von einem anderen Ort übernommen werden kann. Die Quelle jedes Zeichens ist der Titelteil der folgenden Seite der englischen Version von Wikipedia.

HelloWorld.java

import java.util.List;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class HelloWorld {
	public static void main(String[] args) {
		//Wiki-Seite behalten
		String[] url = {"Harry_Potter",
				"The_Human_Centipede_(First_Sequence)",
				"Flying_Spaghetti_Monster",
				"Lil_Wayne",
				"Konjac",
				"Null_pointer",
				"Wikipedia",
				"Morgan_Freeman",
				"Starbucks",
				"Family_Guy",
				"Angry_Birds"};
		//Enthält die Nummer des Zielzeichens im Titel
		int[] location = {0,2,1,2,1,4,0,1,3,4,9};
		
		String helloWorld = makeHelloWorld(url,location);
		System.out.println(helloWorld);
	}
	
	private static String makeHelloWorld(String[] url, int[] location) {
    	System.setProperty("webdriver.chrome.driver", "Wo sich der Chromtreiber befindet");
    	WebDriver driver = new ChromeDriver();
    	
    	//Variablen, die Ergebnisse enthalten
    	String result = "";
    	//HTML-Element mit der Zeichenfolge zu erhalten(Diesmal der Klassenname des Titelteils)
    	String target = "firstHeading";
    	
    	for (int i = 0; i < url.length; i++) {
    		driver.get("https://en.wikipedia.org/wiki/" + url[i]);
    		//Holen Sie sich Zeichen aus HTML-Elementen
        	List<WebElement> values = driver.findElements(By.className(target)); 
        	for (WebElement t : values){
        	    String value = t.getText();
        	    //Schneiden Sie ein Zeichen aus der erfassten Zeichenfolge aus
        	    char letter = value.charAt(location[i]);
        	    result += letter;
        	}
    	}
    	return result;
	}
}

Ausführungsergebnis: Hello World Es dauerte viel länger als zuvor.

Die "Hallo Welt" und übersetzt von Google API Ausgabe

Personen, die diesen Typ nicht in Nantes "Hello World" auf Englisch eingeben möchten, lassen ihn schreiben: "Hello World" wird mithilfe der Google-API auf Japanisch übersetzt. Die hier verwendete Cloud-Übersetzungs-API von Google. Wenn Sie jedoch eine Anfrage wie "https://www.googleapis.com/language/translate/v2?key=your key & q = Hello & source = en & target = ja" stellen, Sie erhalten eine solche Antwort. Lass es uns sofort benutzen

HelloWorld.java

package HelloWorld;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

import org.json.JSONArray;
import org.json.JSONObject;

public class HelloWorld {

	public static void main(String[] args) {
		//Japanisch vor der Übersetzung
		String ja = "Hallo Welt";
		
		//Schlüssel zur Verwendung der Google-API
		String key = "Dein Schlüssel";
		String baseUrl = "https://www.googleapis.com/language/translate/v2?key=";
		//Erstellen Sie eine URL, an die die Anfrage gesendet werden soll
		String urlText = baseUrl + key + "&q=" + ja + "&source=ja&target=en";
		
		try {
			//Kommunizieren
			URL url = new URL(urlText);
			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
			//Geben Sie die GET-Methode an
			conn.setRequestMethod("GET");
			InputStream in = conn.getInputStream();
			BufferedReader reader = new BufferedReader(new InputStreamReader(in));
			StringBuilder output = new StringBuilder();
			String line;
			while ((line = reader.readLine()) != null) {
				output.append(line);
			}
			//Konvertieren Sie den Antwortinhalt in den JSONObject-Typ
			JSONObject json = new JSONObject(output.toString());
			//Stöbern Sie in dem Teil, in dem das Ergebnis gespeichert ist
			JSONObject data = json.getJSONObject("data");
			JSONArray translations = data.getJSONArray("translations");
			JSONObject firstItem = (JSONObject)translations.get(0);
			String result = firstItem.getString("translatedText");
			System.out.println(result);
		}catch(IOException e) {
			System.out.println(e.getMessage());
		}
	}

}

Ausführungsergebnis: Hello World Sie können Hello World ohne Englisch ausgeben.

Erstellen Sie ein Servlet auf dem virtuellen Server, das nur "Hello World" zurückgibt.

Erstellen Sie dieses Mal ein Servlet, das nur die Antwort "Hello World" zurückgibt, laden Sie es auf den virtuellen Server hoch und erstellen Sie ein Programm, das die Zeichenfolge "Hello World" erhält, indem Sie darauf zugreifen. Zunächst der Servlet-Teil.

HelloWorld.java

package HelloWorld;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloWorld extends HttpServlet{

//Beim Aufruf durch die GET-Methode
public void doGet(HttpServletRequest request, HttpServletResponse response)
		      throws ServletException, IOException {
	   
      response.setContentType("text/plain");

      PrintWriter out = response.getWriter();
      out.println("Hello World");
   }
}

Ich werde dies auf einen virtuellen Server hochladen, der mit Virtual Box erstellt wurde. Ich werde kurz erklären, dass Apache und Tomcat installiert sind. Erstellen Sie zunächst das folgende Verzeichnis.

tomcat
　　 ┣　webapps
　　　　　┣　HelloWorld (Neu hinzugefügt unten)
　　　　　　　　┗　WEB-INF
　　　　　　　　　　　┣　web.xml(Ich werde es später erklären)
　　　　　　　　　　　┗　classes
　　　　　　　　　　　　　　┗　HelloWorld
                            ┗ HelloWorld.java (Der mit dem Quellcode oben)
　　　　　┣　docs
　　　　　┣　examples
　　　　　┣　host-manager
　　　　　┗　manager
　　┗　work

Durch Optimieren von web.xml können Sie die Anforderungs-URL und die Servlet-Datei verknüpfen. Die Beschreibung von web.xml lautet wie folgt.

web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
  version="2.4">

  <servlet>
    <servlet-name>HelloWorld</servlet-name>
    <servlet-class>HelloWorld.HelloWorld</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>HelloWorld</servlet-name>
    <url-pattern>/HelloWorldApi</url-pattern>
  </servlet-mapping>

</web-app>

Außerdem werden wir mit den Apache-Einstellungen spielen. Fügen Sie die folgende Beschreibung am Ende der httpd.conf hinzu (ich denke, sie befindet sich in / etc / httpd / conf / für CentOS). ProxyPass /HelloWorld/ ajp://localhost:8009/HelloWorld/ Jetzt wird die Anfrage unter / HelloWorld von Apache an Tomcat übergeben.

Kompilieren Sie mit dem Befehl javac und der Servlet-Teil ist abgeschlossen. Wenn Sie versuchen, die URL über den Browser abzurufen, können Sie feststellen, dass die Informationen wie unten gezeigt ordnungsgemäß abgerufen werden.

Erstellen Sie schließlich eine Klasse, die dieses Servlet verwendet.

HelloWorld.java

package HelloWorld;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HelloWorld{
	public static void main(String[] args) {
		try {
			//URL für eine Anfrage an das Servlet
			URL url = new URL("http://192.168.33.10/HelloWorld/HelloWorldApi");
			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
			conn.setRequestMethod("GET");
			InputStream in = conn.getInputStream();
			BufferedReader reader = new BufferedReader(new InputStreamReader(in));
			StringBuilder output = new StringBuilder();
			String line;
			while ((line = reader.readLine()) != null) {
				output.append(line);
			}
			System.out.println(output.toString());
		}catch(IOException e) {
			System.out.println(e.getMessage());
		}
	}
}

Ausführungsergebnis: Hello World Ich kann die Informationen richtig bekommen.

Platzieren Sie das Servlet im Docker anstelle des virtuellen Servers

Im obigen Beispiel wurde das Servlet auf dem virtuellen Server platziert, aber wir werden eine Umgebung für Apache und Tomcat mit Docker erstellen und das Servlet dort platzieren. Ich habe auf den Artikel von [@ shintaro123] verwiesen (https://qiita.com/shintaro123/items/a8a3d222d3dd46aba876). Erstellen Sie zunächst das folgende Verzeichnis.

docker
┣　httpd
　　┣　Dockerfile (※1)
　　┣　httpd-proxy.conf
　　┗　run-httpd.sh
┗　tomcat
　　┣　Dockerfile　（※2）
┣ Hallo Welt (im Folgenden ist das gleiche wie oben)
　　　　┗　WEB-INF
　　　　　　┗　web.xml
　　　　　　　　┗　classes
　　　　　　　　　　┗　HelloWorld
                    　┗ HelloWorld.java 
   ┗ docker-compose.yml　(※3)

• 1 Datei

/docker/httpd/Dockerfile

FROM centos:7
  
RUN yum -y update && yum clean all
RUN yum -y install httpd httpd-devel gcc* make && yum clean all

ADD httpd-proxy.conf /etc/httpd/conf.d/
ADD run-httpd.sh /run-httpd.sh
RUN chmod -v +x /run-httpd.sh

CMD ["/run-httpd.sh"]

• 2 Datei

/docker/tomcat/Dockerfile

FROM tomcat:9.0.1-alpine

COPY HelloWorld /usr/local/tomcat/webapps/HelloWorld/

RUN rm -rf /usr/local/tomcat/webapps/ROOT

CMD ["catalina.sh","run"]

• 3 Datei

/docker/docker-compose.yml

version: '3'
services:
  httpd:
    container_name: httpd-container
    build: ./httpd
    ports:
      - "80:80"
  tomcat:
    container_name: tomcat-container
    build: ./tomcat
    expose:
      - "8009"
volumes:
  data: {}

CD zu / Docker /

docker-compose build --no-cache
docker-compose up -d

Sie können Informationen vom Servlet abrufen, indem Sie den Befehl eingeben. Die Datei, die Hello World ausgibt, ist dieselbe wie beim Platzieren des Servlets auf dem virtuellen Server.

Generieren Sie eine zufällige Zeichenfolge, warten Sie auf "Hello World" und geben Sie sie aus

Dies ist die Idee von Kilisame. Es erstellt zufällig eine Zeichenfolge und gibt sie aus, wenn sie zu "Hello World" wird. Wenn die Zeichenfolge vollständig zufällig generiert wird, endet sie nicht für immer, sodass die Zeichen zufällig aus den acht Zeichentypen "H", "e", "l", "o", "", "W", "r" und "d" ausgewählt werden. Machen Sie eine Linie.

HelloWorld.java

package HelloWorld;

import java.util.Random;

public class HelloWorld{
	public static void main(String[] args) {
		final String[] letters = {"H","e","l","o"," ","W","r","d"};
		
		Random random = new Random();
		//Enthält eine zufällig generierte Zeichenfolge
		String helloWorld = "";
		//Wenn true, beenden Sie die while-Anweisung unten
		boolean done = false;
		//Verfolgen Sie, wie viele Schleifen Sie erfolgreich waren, da dies eine große Sache ist
		double count = 0;
		while (done == false) {
			count += 1;
			helloWorld = "";
			for (int i = 0; i < 11; i++) {
				int randomNum = random.nextInt(8);
				String helloChar = letters[randomNum];
				helloWorld += helloChar;
			}
			if(helloWorld.equals("Hello World")) {
				done = true;
			}
			System.out.println(helloWorld);
		}
		System.out.println(helloWorld);
		System.out.println("At " + count + "th Time");
		
	}

}

Ausführungsergebnis: Hallo Welt At 7.98865771E8th Time 798.685.771. Erfolg

Zusammenfassung

Hello World scheint gut zu sein, um normal auszugeben. Wenn Sie eine komplexere Hello World-Ausgabemethode finden, schreiben Sie diese in die Kommentare.