Caesar_verschluesselung.java

package caesar_verschluesselung;

import java.util.ArrayList;
import java.util.Scanner;

/**
 *
 * @author Justin Irsch
 */
public class Caesar_verschluesselung {

    public static void main(String[] args) {
        ArrayList<Character> verschluesselterText = new ArrayList<>();
        ArrayList<Character> unverschluesselterText = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);

        Einlesen ein = new Einlesen();

        System.out.print("Um wieviele Stellen soll verschoben werden? (1-127): ");

        int offset = scanner.nextInt(); // Verschiebung wählen, um wieviele Zeichen die Buchstaben verschoben werden sollen

        ArrayList<String> dieZeilen = new ArrayList<>();

        dieZeilen = ein.einlesen("NeuronaleNetze.txt");

        /*System.out.print("Zu verschlüsselnden Text eingeben: ");
        
        String text = scanner.nextLine(); // Text eingeben*/
        for (int a = 0; a < dieZeilen.size(); a++) {

            String text = dieZeilen.get(a);

            if (offset >= 0 && offset <= 127) {

                char[] meinArray = text.toCharArray(); // den Text in ein Char Array laden

                char[] meinNeuesArray = verschluesseln(offset, meinArray);
                // mit der Methode (siehe unten) "verschluesseln" ein neues 
                // Char Array mit dem verschlüsselten Text erstellen

                // verschlüsselten Text abspeichern für die spätere Ausagbe:
                for (int i = 0; i < meinNeuesArray.length; i++) {
                    verschluesselterText.add(meinNeuesArray[i]);
                }

                meinNeuesArray = entschluesseln(offset, meinNeuesArray);

                // entschlüsselten Text wieder ausgeben:
                for (int i = 0; i < meinNeuesArray.length; i++) {
                    unverschluesselterText.add(meinNeuesArray[i]);
                }

                scanner.close();
            } else {
                System.out.println("Die Verschiebung muss zwischen 1 und 127 liegen!");
            }

        }

        String old = "";
        String neu = "";

        for (int b = 0; b < verschluesselterText.size(); b++) {

            old = verschluesselterText.get(b).toString();

            neu = neu + old;

        }
        System.out.println(neu);

        String old2 = "";
        String neu2 = "";

        for (int c = 0; c < unverschluesselterText.size(); c++) {

            old2 = unverschluesselterText.get(c).toString();

            neu2 = neu2 + old2;

        }

        System.out.println("");
        System.out.println("-----------");
        System.out.println("\n Nun kommt wieder die unverschlüsselte Nachricht:");
        System.out.println(neu2);

    }

    // hier ist die Methode zum verschlüsseln
    public static char[] verschluesseln(int offset, char[] charArray) {

        char[] cryptArray = new char[charArray.length]; // leeres char Array

        for (int i = 0; i < charArray.length; i++) {

            int verschiebung = (charArray[i] + offset) % 128;
            // ursprüngliches Zeichen plus Offset modulo 128

            cryptArray[i] = (char) (verschiebung); // Hier wird die Verschiebung gecastet

        }
        return cryptArray;

    }

    // hier ist die Methode zum entschlüsseln
    public static char[] entschluesseln(int offset, char[] charArray) {

        char[] cryptArray = new char[charArray.length];// leeres char Array

        int verschiebung;

        for (int i = 0; i < charArray.length; i++) {

            if (charArray[i] - offset < 0) {
                verschiebung = charArray[i] - offset + 128;
            } // nach Verschiebung kleiner 0? Wenn ja, dann 128 addieren
            else {
                verschiebung = (charArray[i] - offset) % 128;
            }// wenn nein, einfach nur modulo 128
            
            
            cryptArray[i] = (char) (verschiebung); // Hier wird dann zurück gecastet

        }
        return cryptArray;

    }

}

Einlesen.java

package caesar_verschluesselung;


import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;


/**
 *
 * @author Justin Irsch
 */
public class Einlesen {
    
    public ArrayList<String> einlesen(String dateiname) {
        ArrayList<String> e = new ArrayList<>();
        try {
            Scanner sc = new Scanner(new File(dateiname));
            while (sc.hasNext()) {
                e.add(sc.nextLine());
            }

        } catch (FileNotFoundException ex) {
            System.err.println("Fehler beim Einlesen !");
        }

        return e;
    }
    
    
}

NeuronaleNetze.txt

ZDNet / Innovation 
Google stellt zweite Generation seiner AI-Plattform vor
Die neuen Cloud TPUs sollen nicht nur Google-Produkte verbessern. Unternehmen und Drittentwickler können sie über die Google Compute Engine nutzen. Mit AutoML will der Internetkonzern beweisen, das neuronale Netze selbst wieder neuronale Netze schaffen können. 
von Bernd Kling am 18. Mai 2017 , 19:10 Uhr
Google hat seine nächste Generation von Spezial-Chips für maschinelles Lernen angekündigt, ein Teilgebiet künstlicher Intelligenz (Artificial Intelligence, AI). Die Cloud TPUs (Tensor Processing Units) sollen die schnellere und effizientere Abarbeitung von Algorithmen für maschinelles Lernen erlauben. Sie sollen nicht nur Googles eigene Dienste beflügeln, sondern über die Google Compute Engine auch für Unternehmen und unabhängige Entwickler verfügbar werden.
„Es ist uns wichtig, diese Fortschritte allen zugute kommen zu lassen – nicht nur den Nutzern von Google-Produkten“, versichert CEO Sundar Pichai in einem Blogeintrag. Zu erwarten seien große Durchbrüche bei komplexen gesellschaftlichen Problemen, wenn Wissenschaftler und Ingenieure über leistungsfähigere Werkzeuge für Computing und Forschung verfügen. „Aber heute gibt es noch zu viele Barrieren, die dem entgegenstehen.“

Tensor-Processing-Unit–Board (Bild: Google)
AI könnte beispielsweise zugänglicher werden durch die vereinfachte Schaffung von Maschinenlernen-Modellen, die als neuronale Netze bezeichnet werden. Heute sei das Entwerfen eines neuronalen Netzes extrem zeitintensiv und bedürfe großer Expertise. Der Internetkonzern will nun mit AutoML als neuer Herangehensweise zeigen, dass neuronale Netze ihrerseits neuronale Netze konzipieren können. Er hofft, dass AutoML mit Fähigkeiten aufwartet, über die heute nur wenige Hochschulabsolventen verfügen. In drei bis fünf Jahren soll es Hunderttausenden von Entwicklern ermöglichen, neuronale Netze für ihre speziellen Anforderungen zu schaffen.
Als Hardware-Grundlage kommt die Tensor Processing Unit in Googles Rechenzentren zur Beschleunigung von maschinellem Lernen zum Einsatz. Leistungsdaten der Spezial-Chips enthüllte Google erst im letzten Monat. Schon die erste TPU-Generation sorgte demnach für einen gewaltigen Leistungssprung bei Anwendungen mit trainierten neuronalen Netzen.
Die für künstliche Intelligenz optimierten Chips stehen heute hinter beantworteten Suchanfragen und unterstützen Dienste wie die Bildersuche, Google Photos und die Google-Cloud-Vision-API. Sie sollen auch erhebliche qualitative Verbesserungen von Google Translate im letzten Jahr ermöglicht haben. Nicht zuletzt hätten sie beim Sieg von Googles KI-Programm AlphaGo gegen den weltweit besten Spieler des klassischen asiatischen Brettspiels Go geholfen.
Google-Chef Sundar Pichai sieht in diesem Zusammenhang einen neuen Übergang im Computing – die Verlagerung von „Mobile first“ zu „AI first“. „Wie schon bei früheren Veränderungen zwingt uns das, unsere Produkte von Grund auf neu zu denken für eine Welt, die eine natürlichere, nahtlosere Interaktion mit Technologie ermöglichen“, schreibt er. Beispielhaft verweist er dabei auf die „sehende“ Kamera dank Google Lens sowie das per Sprache bedienbare und antwortende Smartphone.