Ce que j'ai appris avec Java Gold

Décrivez ce que vous avez appris dans Java Gold avec la collection de problèmes Java SE8 Gold (Kuromoto).

Chapitre 1 Conception de classe Java

• La méthode hashCode des objets permet d'améliorer les performances de recherche.

• La signification du modificateur final diffère selon la classe, la variable et la méthode.

• Classe: non héritable

• Variable: non réaffectable, c'est-à-dire constante

• Méthode: ne peut pas être remplacée

• ** Final peut être ajouté à l'argument ** (je ne savais pas ...)

• Le code dans l'initialiseur statique est exécuté lorsque la classe est chargée

• Caractéristiques de la classe Singleton

• Créer sa propre instance avec un champ statique privé

• Déclarez le constructeur comme privé

• Préparez une méthode en statique public qui renvoie l'instance définie dans le champ

• À propos de l'héritage du diamant. Si une méthode est écrasée par l'héritage multiple d'une interface, une erreur de compilation se produira si la distance est la même, mais si la distance la plus proche est déterminée de manière unique, la plus proche sera adoptée.

package tryAny.diamondExtends;

public interface A {
    default void x() {
	System.out.println("I am A.");
    }
}

package tryAny.diamondExtends;

public interface B extends A {

}

package tryAny.diamondExtends;

public interface C extends A {
    default void x() {
	System.out.println("I am C.");
    }
}

package tryAny.diamondExtends;

public class DiamondExtends implements B, C {
    public static void main(String[] args) {
	DiamondExtends de = new DiamondExtends();
	de.x();// I am C.Production
    }
}

• Il existe une classe imbriquée. (Contrairement à cela, les classes ordinaires sont appelées classes de premier niveau)

• classe membre statique, classe interne

• La classe externe est appelée la classe englobante. La classe englobante n'est pas nécessairement la classe de niveau supérieur.

• L'utilisation des classes imbriquées est la suivante selon Perfect Java

• Lors de l'utilisation d'un objet uniquement à l'intérieur de la classe englobante

• Si vous souhaitez masquer l'implémentation de classe imbriquée dans la classe englobante

package tryAny.inner;

public class InnerTest {
    class InnerA {
	void innerMethod() {
	    System.out.println("I am inner.");
	}
    }

    private void execInner() {
	InnerA ia = new InnerA();
	ia.innerMethod();
    }

    public static void main(String[] args) {
	InnerTest it = new InnerTest();
	it.execInner();
    }
}

package tryAny.inner;

public class Other {
    public static void main(String[] args) {
	InnerTest.InnerA ia = new InnerTest().new InnerA();
	ia.innerMethod();
    }
}

• Lorsqu'une classe anonyme est utilisée, ** utilise souvent des méthodes d'autres classes déclarées pour prendre des arguments de type d'interface **

package tryAny.anonymous;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class AnonymousTest {
    public static void main(String[] args) {
	Data d1 = new Data(3, "aaa");
	Data d2 = new Data(1, "bbb");
	Data d3 = new Data(2, "ccc");

	List<Data> list = new ArrayList<Data>();
	list.add(d1);
	list.add(d2);
	list.add(d3);

	list.stream().forEach(System.out::println);// 3,1,Affichage par ordre de 2

	list.sort(new Comparator<Data>() {
	    public int compare(Data data1, Data data2) {
		if (data1.num > data2.num) {
		    return 1;
		} else {
		    return -1;
		}
	    }
	});

	list.stream().forEach(System.out::println);// 1,2,Affichage par ordre de 3
    }

    static class Data {
	int num;
	String value;

	Data(int num, String value) {
	    this.num = num;
	    this.value = value;
	}

	@Override
	public String toString() {
	    return num + ":" + value;
	}
    }
}

• Enum ne peut pas hériter d'autres classes, mais peut implémenter des interfaces
• La même chaîne de caractères que le nom de la constante d'énumération peut être prise avec name () et toString ().
• Vous pouvez obtenir un tableau d'énumération avec values ().

package tryAny.enumTes;

public enum Gender {
    MAN, WOMAN, OTHER;
}

class Try {
    public static void main(String[] args) {
	System.out.println(Gender.MAN.toString());// MAN
	System.out.println(Gender.MAN.name());// MAN
	for (Gender g : Gender.values()) {
	    System.out.println(g.name() + ":" + g.ordinal());
	    /**
	     * MAN:0 </br>
	     * WOMAN:1 </br>
	     * OTHER:2
	     */
	}
	Gender g = Gender.MAN;

	trans(g);//Homme
    }

    public static void trans(Gender g) {
	switch (g) {
	case MAN:
	    System.out.println("Homme");
	    break;
	case WOMAN:
	    System.out.println("femme");
	    break;
	case OTHER:
	    System.out.println("Autre");
	    break;
	default:
	    assert (false);
	}
    }
}

• Enum ne peut déclarer que des constructeurs privés.

Chapitre 2 Collection et génériques

• Directives de dénomination des variables de type

• Les éléments stockés dans la collection sont ** E **

• Les clés et les valeurs stockées dans la carte sont ** K ** et ** V **, respectivement.

• Les types généraux autres que ceux ci-dessus sont ** T **

• ** R ** pour le type de retour

• Le type primitif ne peut pas être spécifié dans l'argument type.

• La déclaration de variable et l'argument de type de l'instanciation doivent correspondre. Par conséquent, à partir de JavaSE7, il est possible d'omettre l'argument type dans l'instanciation comme suit.

Foo<Integer> foo = new Foo<>();

• Une seule classe générique est créée en interne avec la partie variable de type remplacée par Object. Par conséquent, les variables de type ne peuvent pas être des champs de classe et ne peuvent pas être des valeurs de retour ou des arguments de méthodes de classe. (Je ne comprends pas entièrement cette logique)

package tryAny.Generic;

public class GenericTest<T> {
    /**
     *Cela peut être compilé car T au moment de la déclaration de classe et T dans la méthode ci-dessous sont différents.
     */
    static <T> T exec3(T t) {
	return t;
    }

    /**Ce qui suit ne compile pas
    static T exec(T t) {
	return t;
    }
    **/
}

• Vous pouvez mettre des restrictions sur les variables de type en utilisant des contraintes de limite de type.

//T est limité au sous-type Number.
class Foo<T extends Number> {}

package tryAny.Generic;

public class BoundedType {
    public static void main(String[] args) {
	Hoge<Foo, Bar> h1 = new Hoge<Foo, Bar>();//Compiler via
	Hoge<Foo, Foo> h2 = new Hoge<Foo, Foo>();//Compiler via
	// Hoge<Bar, Foo> h3 = new Hoge<Bar, Foo>();//Ne compile pas
    }
}

abstract class Foo {
}

class Bar extends Foo {
}

class Hoge<T, U extends T> {
}

• Vous pouvez utiliser le caractère générique **? ** Pour les arguments de type.

• : Une sous-classe de T, ou T
• : super classe de T, ou T

• Lors de l'héritage d'une classe générique, la variable de type doit être fixe.

• Comparaison de ArrayList et LinkedList

• ArrayList a un accès aléatoire rapide aux éléments, mais le coût de l'ajout d'éléments à la liste est élevé

• LinkedList a un accès aléatoire plus lent que ArrayList, mais coûte moins cher pour ajouter des éléments

• ClassCastException est levée si l'élément stocké dans le TreeSet n'est pas de type Comparable .

• La variable qui reçoit la valeur de retour de la référence constructeur doit être une interface fonctionnelle (ce qui est évident, si vous y réfléchissez).

package tryAny.lambda;

public interface Flyable {
    AirPlane getAirPlane(String name);
}

package tryAny.lambda;

public class LambdaTest6 {
    public static void main(String[] args) {
        Flyable f = AirPlane::new;
        AirPlane ap = f.getAirPlane("ana");

        System.out.println(ap);
    }
}

class AirPlane {
    private String name;

    public AirPlane(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "constructor " + this.name;
    }
}

• Où les variables de type peuvent être utilisées dans la définition de type générique
• Type de variable de champ d'instance (y compris l'argument de type)
• Type de retour de la méthode d'instance
• Type de variable locale dans la méthode d'instance
• Type de variable de paramètre dans la méthode d'instance
• Nom du type de type imbriqué
• Où les variables de type ne peuvent pas être utilisées dans la définition de type générique
• Type de variable de champ de classe
• Type de retour de la méthode de classe
• Type de variable locale dans la méthode de classe
• Type de variable de paramètre dans la méthode de classe
• Nouvel opérande d'opérateur

Chapitre 3 Expressions Lambda et interfaces de fonctions intégrées

• Expression Lambda → Peut décrire de manière concise l'implémentation d'une classe interne anonyme

package tryAny.lambda;

public class LambdaTest {
    public static void main(String[] args) {
	Runnable r1 = new Runnable() {
	    public void run() {
		System.out.println("run1");
	    }
	};

	//le même
	Runnable r2 = () -> System.out.println("run2");

	Thread t1 = new Thread(r1);
	Thread t2 = new Thread(r2);
	t1.start();
	t2.start();
    }
}

• Objets de première classe → Objets qui peuvent être manipulés de la même manière que les littéraux
• Fonction d'ordre supérieur-> Une fonction qui vous permet de passer une fonction en tant qu'argument d'une fonction et de renvoyer la fonction en tant que valeur de retour de la fonction.
• Dans les expressions lambda, le type d'argument peut toujours être omis. De plus, s'il n'y a qu'un seul argument, () peut être omis. Si () est omis, le type d'argument ne peut pas être décrit.
• Les quatre suivantes sont des interfaces fonctionnelles typiques préparées à l'avance.
• Fournisseur : ne prend aucun argument et renvoie une valeur de type T. Méthode T get ()
• Prédicat : évalue la valeur de type T reçue comme argument. méthode de test booléen (T t)
• Consommateur : reçoit le type T comme argument et exécute le traitement (pas de valeur de retour). vide accepter (T t)
• Fonction <T, R>: reçoit le type T comme argument, exécute le traitement et renvoie la valeur de type R. R appliquer (T t)

package tryAny.lambda;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class LambdaTest2 {
    public static void main(String[] args) {
	Supplier<String> s = () -> "supplier";
	Predicate<String> p = str -> "supplier".equals(str);
	Consumer<String> c = str -> System.out.println(str);
	Function<String, Integer> f = str -> str.length();

	// "supplier"Le nombre de caractères de.
	if (p.test(s.get())) {
	    c.accept(f.apply(s.get()).toString());
	}
    }
}

• UnaryOperator a le type T pour l'argument et la valeur de retour. Autrement dit, il peut être considéré comme une fonction <T, T>.
• BinaryOperator est identique à BiFunction <T, T, T> comme ci-dessus.
• Il est également possible de spécifier une fonction pour une variable de type. Par exemple, vous pouvez spécifier une fonction dans R de IntFunction .

package tryAny.lambda;

import java.util.function.IntFunction;
import java.util.function.IntUnaryOperator;
import java.util.stream.IntStream;

public class LambdaTest3 {
    public static void main(String[] args) {
        IntStream s1 = IntStream.of(1, 2, 3);
        IntFunction<IntUnaryOperator> func = x -> y -> x + y;

        IntStream s2 = s1.map(func.apply(2));
        s2.forEach(System.out::println);
    }
}

• Référence de méthode → Syntaxe qui peut être utilisée lorsque l'expression lambda est complétée uniquement en appelant une méthode, et la signature de la méthode abstraite SAM et la méthode appelée par l'expression lambda sont les mêmes.
• L'explication de la page suivante est facile à comprendre pour la correspondance entre les références de méthode et les expressions lambda. http://www.ne.jp/asahi/hishidama/home/tech/java/methodreference.html

Chapitre 4 API Stream

• Stream dans l'API Stream est un concept différent d'InputStream et OutputStream.
• Une opération intermédiaire est effectuée lorsque l'opération de terminaison est effectuée. (** Évaluation du retard **)
• L'opération de terminaison ne peut être effectuée qu'une seule fois pour le même flux.
• Renvoie un flux avec Arrays.stream.

package tryAny.stream;

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamTest1 {
    public static void main(String[] args) {
	String[] strAry = { "a", "b", "c" };
	Stream<String> strStream = Arrays.stream(strAry);
	strStream.forEach(System.out::println);

	int[] intAry = { 1, 2, 3, 4, 5 };
	IntStream intStream = Arrays.stream(intAry);
	intStream.forEach(System.out::println);

	IntStream intStream2 = Arrays.stream(intAry, 2, 4);
	intStream2.forEach(System.out::println);
	/**
	 * 3</br>
	 * 4
	 */

	IntStream.range(0, 4).forEach(System.out::print);// 0123
	IntStream.rangeClosed(0, 4).forEach(System.out::print);// 01234

    }
}

• Utilisez Stream.of () pour créer un flux d'objets de type référence arbitraire.

package tryAny.stream;

import java.util.stream.Stream;

public class StreamTest2 {
    public static void main(String[] args) {

	Stream<Data> s = Stream.of(new StreamTest2().new Data("a", 1), new StreamTest2().new Data("b", 2));
	// "a:1 b:2 "

	s.forEach(System.out::print);
    }

    class Data {
	String str;
	int i;

	public Data(String s, int i) {
	    this.str = s;
	    this.i = i;
	}

	@Override
	public String toString() {
	    return this.str + ":" + this.i + "  ";
	}
    }
}

• La méthode lines de BufferedReader et la méthode lines de la classe Files renvoient un flux.

package tryAny.stream;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class StreamTest3 {
    public static void main(String[] args) {
	try (BufferedReader br = new BufferedReader(new FileReader("src/main/java/tryAny/stream/sample.txt"))) {
	    br.lines().forEach(System.out::println);

	    Files.lines(Paths.get("src/main/java/tryAny/stream/sample.txt")).forEach(System.out::println);
	} catch (IOException e) {
	    e.printStackTrace();
	}

    }
}

• Vous pouvez aplatir une liste imbriquée en utilisant flatMap.
• flatMapToInt renvoie IntStream.

package tryAny.lambda;

import java.util.Arrays;
import java.util.stream.IntStream;

public class LambdaTest4 {
    public static void main(String[] args) {
        int[][] data = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
        IntStream s1 = Arrays.stream(data).flatMapToInt(Arrays::stream);
        s1.forEach(System.out::print);// 123456
    }
}

• Vous pouvez supprimer les doublons avec distinct ().

package tryAny.stream;

import java.util.Arrays;
import java.util.List;

public class StreamTest5 {
    public static void main(String[] args) {
	List<List<String>> l = Arrays.asList(Arrays.asList("banana", "apple"), Arrays.asList("banana", "orange"));

	l.stream().flatMap(li -> li.stream()).distinct().forEach(System.out::println);

	List<List<List<String>>> l2 = Arrays.asList(Arrays.asList(Arrays.asList("pineapple", "grape")));

	l2.stream().flatMap(li2 -> li2.stream()).flatMap(li3 -> li3.stream()).forEach(System.out::println);
    }
}

• Dans Map merge (K key, V value, BiFunction remappingFunction), si la clé existe, le résultat de l'exécution de la remappingFunction en utilisant la valeur sera la valeur correspondant à la clé. Si la clé n'existe pas, la valeur devient la valeur de la clé telle quelle.

package tryAny.stream;

import java.util.HashMap;
import java.util.Map;

public class StreamTest6 {
    public static void main(String[] args) {
	Map<String, Integer> m = new HashMap<>();
	m.put("A", 1);
	m.merge("A", 2, (v1, v2) -> v1 * v2);
	m.merge("b", 1, (v1, v2) -> v1 * v2);

	System.out.println(m);
	// {A=2, b=1}

    }
}

• La terminaison qui résume un ensemble de données en une seule est appelée réduction.
• Un collecteur qui implémente l'interface Collector est appelé un collecteur. Cela détermine quels éléments sont collectés dans quel conteneur variable. Il existe quatre opérations de réduction variable comme suit.
• Prétraitement
• Accumulation
• Combiner
• Post-traitement
• Vous pouvez utiliser l'utilitaire java.util.stream.Collections pour créer un objet Collector.

package tryAny.stream;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTest8 {
    public static void main(String[] args) {
	/**
	 * Collectors.toList()L'objet Collector créé par</br>
	 *Accumulez les éléments d'entrée dans List.
	 */
	List<String> l = Stream.of("paper", "book", "photo").collect(Collectors.toList());

	l.stream().forEach(System.out::println);

	// Collector<Integer,Map<String,Integer>,Map<String,List<Integer>>>
	// collector
	// = Collectors.groupingBy(Integer;]

	//Regrouper par nombre de caractères
	Map<Integer, List<String>> map = l.stream().collect(Collectors.groupingBy(e -> e.length()));
	map.forEach((v1, v2) -> System.out.println(v1 + ":" + v2));
	/**
	 * 4:[book]</br>
	 * 5:[paper, photo]
	 */

	//Groupe après l'acronyme
	Map<Character, List<String>> map2 = l.stream().collect(Collectors.groupingBy(e -> e.charAt(0)));
	map2.forEach((v1, v2) -> System.out.println(v1 + ":" + v2));
    }
}

• À propos de l'interface de fonction lorsqu'il s'agit de types de base
• Si la valeur de retour est R et l'argument de apply est int, utilisez IntFunction .
• Si la valeur de retour est int et l'argument de applyAsInt est T, utilisez ToIntFunction .

package tryAny.lambda;

import java.util.function.IntFunction;
import java.util.function.ToIntFunction;

public class LambdaTest7 {
    public static void main(String[] args) {
        //Renvoie le entier pris comme argument en tant que caractère
        IntFunction<String> intFunc = String::valueOf;

        //Renvoie le nombre de caractères de la chaîne pris comme argument
        ToIntFunction<String> toIntFunc = String::length;

        System.out.println(intFunc.apply(11));
        System.out.println(toIntFunc.applyAsInt("apple"));
    }
}

Chapitre 5 Exceptions et affirmations

• Les exceptions interceptées peuvent être stockées dans les exceptions de relance.
• Les exceptions stockées peuvent être obtenues avec getCause ().

package tryAny.exception;

public class ExceptionTest1 {
    public static void main(String[] args) {
	try {
	    x();
	} catch (Throwable e) {
	    while (e != null) {
		System.out.println(e.getMessage());
		e = e.getCause();
	    }
	    /**
	     * from x</br>
	     * from y</br>
	     * from z
	     */
	}
    }

    static void x() throws Exception {
	try {
	    y();
	} catch (Exception e) {
	    throw new Exception("from x", e);
	}
    }

    static void y() throws Exception {
	try {
	    z();
	} catch (Exception e) {
	    throw new Exception("from y", e);
	}
    }

    static void z() throws Exception {
	throw new Exception("from z");
    }
}

• Si vous souhaitez intercepter plusieurs exceptions dans une clause catch, vous pouvez utiliser l'instruction multi-catch.

package tryAny.exception;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ExceptionTest2 {
    public static void main(String[] args) {
	try {
	    BufferedReader br = new BufferedReader(new FileReader("src/main/java/tryAny/stream/sample.txt"));
	    int a = Integer.parseInt("a");
	} catch (IOException | NumberFormatException e) {
	    System.out.println(e);
	}
    }
}

• Les ressources ouvertes peuvent être fermées automatiquement en utilisant l'instruction try-with-resources.

package tryAny.exception;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class ExceptionTest3 {
    public static void main(String[] args) {
	try (FileReader in = new FileReader("src/main/java/tryAny/stream/sample.txt");
		FileWriter out = new FileWriter("src/main/java/tryAny/exception/sample.txt");
		AutoCloseTest act = new AutoCloseTest();
		/** AutoCloseTest2 act2 = new AutoCloseTest2();← Non implémenté car AutoCloseable n'est pas implémenté**/ ) {
	    //La fermeture AutoCloseTest est exécutée.
	} catch (IOException e) {

	}
    }
}

class AutoCloseTest implements AutoCloseable {
    @Override
    public void close() {
	System.out.println("AutoCloseTest is closed.");
    }
}

class AutoCloseTest2 {
    public void close() {
	System.out.println("AutoCloseTest is closed.");
    }
}

• Si l'instruction assert devient fausse, une AssertionError se produira (mettez -ea dans l'argument de ligne de commande).
• L'instruction assert est une fonction du programme en cours de développement et doit être désactivée pendant le fonctionnement réel.

package tryAny.exception;

public class ExceptionTest4 {
    public static void main(String[] args) {
	int x = 1;

	assert (x == 2) : "Envoyez un message d'erreur!";
	/**
	 *Dans l'argument VM-Lorsque je mets ea, j'obtiens l'erreur suivante.
	 *
	 * Exception in thread "main" java.lang.AssertionError:Envoyez un message d'erreur!
	 * at tryAny.exception.ExceptionTest4.main(ExceptionTest4.java:7)
	 *
	 */
    }
}

Chapitre 6 API Date / Heure

• Vous pouvez prendre une classe qui contient l'heure actuelle dans la méthode now () et l'heure spécifiée dans la méthode of.

package tryAny.dateTime;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;

public class DateTest1 {
    public static void main(String[] args) {
	LocalDateTime now = LocalDateTime.now();
	LocalDate ld = LocalDate.of(2018, Month.JANUARY, 1);

	System.out.println(now + " " + ld);
    }
}

• Les méthodes de classe TemporalUnit peuvent être utilisées pour effectuer des calculs de date simples pour calculer la longueur d'une classe ou d'une période qui implémente Temporal.

package tryAny.dateTime;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class DateTest2 {
    public static void main(String[] args) {
	LocalDate ld1 = LocalDate.now();
	LocalDate ld2 = ChronoUnit.YEARS.addTo(ld1, -1);
	long l = ChronoUnit.DAYS.between(ld1, ld2);

	System.out.println(ld1);//maintenant
	System.out.println(ld2);//Il y a un an
	System.out.println(l);//Si vous ne considérez pas l'année de la saison, etc.-365
    }
}

• Il existe une classe de durée et une classe de période en tant que classes représentant la période. Les deux implémentent l'interface Montant Temporel.
• La durée représente une durée basée sur le temps.
• La période représente une période basée sur la date.

package tryAny.dateTime;

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.temporal.ChronoUnit;

public class DateTest3 {
    public static void main(String[] args) {
	LocalDateTime ldt1 = LocalDateTime.now();
	LocalDateTime ldt2 = ChronoUnit.DAYS.addTo(ldt1, 31);

	Duration d = Duration.between(ldt1, ldt2);
	Period p = Period.between(ldt1.toLocalDate(), ldt2.toLocalDate());

	System.out.println(d + " " + p);// PT744H P1M
    }
}

• Vous pouvez utiliser les formats d'affichage de date et d'heure prédéfinis, ou vous pouvez créer les vôtres.

package tryAny.dateTime;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;

public class DateTest4 {
    public static void main(String[] args) {
	DateTimeFormatter dtf1 = DateTimeFormatter.BASIC_ISO_DATE;
	DateTimeFormatter dtf2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);

	System.out.println(dtf1.format(LocalDate.now()));
	System.out.println(dtf2.format(LocalDateTime.now()));

	//Créez votre propre format
	DateTimeFormatter dtf3 = DateTimeFormatter.ofPattern("yyyy★MM★dd");
	System.out.println(dtf3.format(LocalDate.now()));
    }
}

Chapitre 7 Java / IO

• Il existe des classes File et Path qui gèrent les fichiers, mais il est recommandé d'utiliser Path dans Java SE 7 ou version ultérieure.
• Il existe quatre flux d'entrée / sortie, qui sont le produit de l'entrée / sortie et du texte / binaire, et chacun a les classes abstraites suivantes.
• Entrée, texte: lecteur
• Entrée, binaire: InputStream
• Sortie, texte: Writer
• Sortie, binaire: OutputStream
• La conception de classe dans le package java.io est construite avec le modèle Decorator.
• PrintStream et PrintWriter sont presque identiques. Ceux-ci peuvent afficher la valeur du type primitif telle quelle.

package tryAny.io;

import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class IOTest1 {
    public static void main(String[] args) {
	try (PrintWriter pw = new PrintWriter("out.txt")) {
	    pw.println("Hello world");
	    //BufferedWriter ne peut pas générer des types primitifs tels que booléen et doubler tels quels.
	    pw.println(true);
	    pw.println(0.4);
	} catch (FileNotFoundException e) {
	    System.out.println(e);
	}
    }
}

• L'entrée standard peut être lue en utilisant la classe Console. Pour obtenir une instance de console, vous devez appeler la méthode console () de la classe System.
• Les classes qui nécessitent une sérialisation doivent implémenter Serializable. Comprenez que l'interface sérialisable elle-même n'a aucune fonctionnalité et que les classes qui l'implémentent sont responsables d'être sérialisables. http://d.hatena.ne.jp/daisuke-m/20100414/1271228333
• Vous pouvez réellement sérialiser et désérialiser à l'aide de la classe ObjectOutputStream et de la classe ObjectInputStream.

package tryAny.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class IOTest3 {
    public static void main(String[] args) throws IOException {
	//Stocke les données sérialisées.
	try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("iotest3.ser"))) {
	    String test = "iotest3";
	    oos.writeObject(test);//C'est iotest3.Vous pouvez ser.
	    oos.writeInt(111);
	} catch (IOException e) {
	    throw new IOException(e);
	}

	//Obtenez des données sérialisées et étendez-les en mémoire.
	try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("iotest3.ser"))) {
	    System.out.println(ois.readObject());
	    System.out.println(ois.readInt());
	} catch (ClassNotFoundException | IOException e) {
	    throw new IOException(e);
	}
    }
}

• Les variables statiques et les variables avec le modificateur transitoire ne sont pas soumises à la sérialisation.

• Java SE 7 a changé la classe qui gère les fichiers de File en Path, ce qui permet d'utiliser de manière transparente le mécanisme spécifique au système de fichiers de la plate-forme.

• Le comportement par défaut de la classe Files est le suivant. Ces comportements peuvent être modifiés en spécifiant des options dans les arguments.

• Une exception est levée si le fichier de destination existe.

• Les attributs du fichier source de la copie ne sont pas hérités.

• Lors de la copie d'un répertoire, les fichiers du répertoire ne sont pas copiés.

• Lors de la copie d'un lien symbolique, seule la destination du lien est copiée, pas le lien lui-même.

• Les classes qui gèrent les attributs de fichier se trouvent dans le package java.nio.file.attribute et ont les trois suivants.

• BasicFileAttributes: attributs de fichier communs pour Windows et Linux

• DosFileAttributes: attributs de fichier Windows

• PosixFileAttributes: attributs de fichier Linux

• AttributeView est une interface qui représente un ensemble d'attributs de fichier. (** Que signifie un ensemble d'attributs de fichier ?? **)

• Si vous souhaitez obtenir un seul attribut pour un fichier ou un répertoire, vous pouvez utiliser Files.getAttribute.

package tryAny.io;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.FileTime;

public class IOTest5 {
    public static void main(String[] args) throws IOException {
	Path p = Paths.get("out.txt");

	//Date et heure de création
	System.out.println((FileTime) Files.getAttribute(p, "creationTime"));

	//Taille
	System.out.println((long) Files.getAttribute(p, "size"));

	//Que ce soit un lien symbolique
	System.out.println((boolean) Files.getAttribute(p, "isSymbolicLink"));
    }
}

• La méthode walkFileTree facilite la traversée récursive de la hiérarchie des répertoires.
• Si vous utilisez la méthode Files.walk, vous pouvez effectuer un traitement de cheminement avec une recherche de priorité de profondeur.

package tryAny.io;

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;

public class IOTest6 {
    public static void main(String[] args) throws IOException {
	Path p = Paths.get("src");

	//Lorsqu'un fichier apparaît, exportez-le en standard.
	Files.walkFileTree(p, new SimpleFileVisitor<Path>() {
	    @Override
	    public FileVisitResult visitFile(Path path, BasicFileAttributes bfa) throws IOException {
		System.out.println(path);
		return FileVisitResult.CONTINUE;
	    }
	});

	//Affiche uniquement le répertoire.
	Files.walk(p).filter(path -> {
	    try {
		return (boolean) Files.getAttribute(path, "isDirectory");
	    } catch (IOException e) {
		System.out.println(e);
		return false;
	    }
	}).forEach(System.out::println);
    }
}

• La méthode de liste de fichiers renvoie Stream , la méthode de lignes renvoie Stream et readAllLines renvoie List .

Chapitre 8 Parallélisme

• Les utilitaires de concurrence sont fournis dans java.util.concurrent.atomic et java.util.concurrent.locks. Le mécanisme et les fonctions fournis ici sont les suivants.

• Thread pool: Un mécanisme pour éliminer la surcharge de la création de threads en créant et en stockant des threads à l'avance. Le framework Executor fournit cette fonctionnalité

• Collection parallèle: une collection qui offre un bon équilibre entre performance et parallélisme.

• Variable atomique: Une variable qui garantit l'atomicité du traitement, c'est-à-dire un mécanisme qui garantit qu'il ne peut y avoir d'autre situation que le choix d'exécuter ou de ne pas exécuter une certaine fonction. S'il s'agit d'un processus d'incrémentation, il s'agit d'un processus de (1) lecture de la valeur → (2) modification de la valeur → (3) écriture de la valeur, mais il est garanti que le flux de (1) à (3) est soit terminé, soit intact. (On considère qu'un autre traitement écrit dans la variable cible entre ① et ②)

• Comptage du semapho: ** Semafo ** est un mécanisme utilisé pour la synchronisation et le contrôle d'interruption entre les processus et les threads. Il existe des ** sémaphos binaires ** et des ** semafos à compter **. Dans le sémapho binaire, les types de contrôle d'accès aux ressources sont seulement «possibles» et «impossibles», alors que dans le sémapho de comptage, le nombre de ressources accessibles peut être fixé arbitrairement.

• Les variables atomiques garantissent le fonctionnement atomique.

package tryAny.concurrentUtility;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;

public class ConcurrentTest5 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {

	ExecutorService es = Executors.newFixedThreadPool(8);
	MyAtomCounter mac = new MyAtomCounter();

	Future<?> ret1 = es.submit(new MyAtomWorker(mac));
	Future<?> ret2 = es.submit(new MyAtomWorker(mac));

	ret1.get();
	ret2.get();
	es.shutdown();

	//Ce sera certainement 200 000.
	mac.show();

    }
}

class MyAtomCounter {
    private AtomicInteger count = new AtomicInteger();

    public void increment() {
	count.incrementAndGet();
    }

    public void show() {
	System.out.println("Pour AtomicInteger:" + count);
    }
}

class MyAtomWorker implements Runnable {
    private static final int NUM_LOOP = 100000;
    private final MyAtomCounter counter;

    MyAtomWorker(MyAtomCounter counter) {
	this.counter = counter;
    }

    @Override
    public void run() {
	for (int i = 0; i < NUM_LOOP; i++) {
	    counter.increment();
	}
    }
}

• ** La classe ConcurrentHashMap ** est une carte qui peut être manipulée de manière atomique. L'unité à verrouiller est plus fine que l'ensemble de la carte et la dégradation des performances d'exécution est faible, mais size () et isEmpty () peuvent ne pas être précis. En outre, la stratégie de conception Iterator renvoyée par cette classe est ** cohérence faible **, qui autorise les modifications d'éléments lors d'un accès parallèle, de sorte que ConcurrentModificationException ne se produit pas.
• ** La classe CopyOnWriteArrayList ** générera une copie de la liste d'origine lorsqu'une méthode est appelée qui modifie les éléments de la liste. Si une demande de lecture de liste provient d'un autre thread alors que l'élément de liste est en cours de modification, la valeur de la copie créée est renvoyée, de sorte que ConcurrentModificationException ne se produit pas. En raison du mécanisme de copie, si la taille de la liste est importante, les performances se détérioreront.
• La coordination entre plusieurs threads est possible en utilisant la classe CyclicBarrier.

package tryAny.concurrentUtility;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class ConcurrentTest9 {
    public static void main(String[] args) {

        Runnable runner = new Runner();
        CyclicBarrier barrier = new CyclicBarrier(3, runner);

        List<Worker> workers = new ArrayList<Worker>();
        for (int i = 0; i < 3; i++) {
            workers.add(new Worker(barrier));
        }

        workers.stream().parallel().forEach(Worker::run);
        /**
         * 1<br>
         * 2<br>
         * 3<br>
         * All threads have run.
         *
         * 1,2,La partie 3 peut ne pas être le cas. 1,2,C'est comme 1.
         */
    }
}

class Runner implements Runnable {

    @Override
    public void run() {
        System.out.println("All threads have run.");
    }
}

class Worker extends Thread {
    private CyclicBarrier barrier;

    private static int count;

    public Worker(CyclicBarrier barrier) {
        this.barrier = barrier;
    }

    @Override
    public void run() {
        try {
            System.out.println(++count);
            barrier.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

• Dans la classe Thread, la partie "demander à la JVM d'exécuter la tâche" et la partie "comment exécuter la tâche" sont étroitement liées, et il était difficile de contrôler la création et la gestion des threads par programmation. .. À partir de Java SE8, la classe Executor a été introduite pour résoudre ces problèmes.
• Le framework Executor fournit désormais des fonctions telles que la gestion du cycle de vie des tâches, le regroupement des threads, le démarrage différé / l'exécution périodique des tâches, etc.
• En utilisant la classe ScheduledThreadPoolExecutor, les tâches peuvent être démarrées différées et exécutées périodiquement.

package tryAny.concurrentUtility;

import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

//Continue à générer des valeurs aléatoires toutes les secondes.
public class ConcurrentTest6 {
    public static void main(String[] args) {
	ScheduledThreadPoolExecutor stpe = new ScheduledThreadPoolExecutor(1);

	ScheduledFuture<?> sf = stpe.scheduleAtFixedRate(new Runnable() {
	    @Override
	    public void run() {
		System.out.println(Math.random());
	    }
	}, 1000, 1000, TimeUnit.MILLISECONDS);

	while (true) {
	    if (sf.isCancelled() || sf.isDone()) {
		stpe.shutdown();
		break;
	    }
	}
    }
}

• Le but de l'introduction de l'interface Executor est de séparer ** l'exécuteur de tâches ** et la ** méthode d'exécution des tâches **, l'interface exécuteur est en charge de la partie exécuteur de tâches, et le service d'exécuteur et le service d'exécution planifiée sont en charge de la partie méthode d'exécution des tâches. Responsable (classe concrète qui implémente Executor).
• L'objet futur est un objet qui représente le résultat de l'exécution d'une tâche asynchrone.
• L'exécuteur a les trois états suivants.
• Actif: état dans lequel de nouvelles tâches peuvent être acceptées.
• ShuttingDown: état dans lequel les nouvelles tâches ne sont pas acceptées, mais les tâches accumulées dans la file d'attente sont en cours d'exécution.
• Arrêt: aucune nouvelle tâche n'est acceptée et il n'y a aucune tâche dans la file d'attente.
• ** Le framework Fork / Join ** peut être utilisé pour subdiviser les tâches et les traiter efficacement dans plusieurs threads. L'algorithme utilisé ici est le ** Work-stealing **. Un algorithme dans lequel un thread qui termine une tâche subdivisée et assignée tôt fera rebondir la tâche en haut de la file d'attente des threads qui n'ont pas encore terminé toutes les tâches.
• Les tâches du framework Fork / Join sont représentées par la classe abstraite ForkJoinTask, et la partie méthode d'exécution des tâches est gérée par la classe d'implémentation ForkJoinPool.
• Les classes qui héritent de ForkJoinTask incluent la classe ** RecursiveAction ** et ** RecursiveTask **, RecursiveAction n'a pas de valeur de retour et RecursiveTask a une valeur de retour.
• ForkJoinPool a les trois méthodes d'exécution de tâches suivantes.
• exécuter: exécution asynchrone sans valeur de retour
• submit: exécution asynchrone avec valeur de retour
• invoke: exécution synchrone

package tryAny.concurrentUtility;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class ConcurrentTest7 {
    public static void main(String[] args) throws InterruptedException {
	ForkJoinPool jfp = new ForkJoinPool();
	jfp.execute(new MyAction());
	System.out.println("①");
	Thread.sleep(3000);
	System.out.println("②");
	/**
	 * ①</br>
	 * ③</br>
	 * ②
	 */

	jfp.invoke(new MyAction());
	System.out.println("①");
	Thread.sleep(3000);
	System.out.println("②");
	/**
	 * ③</br>
	 * ①</br>
	 * ②
	 */
    }
}

class MyAction extends RecursiveAction {
    @Override
    protected void compute() {
	try {
	    Thread.sleep(2000);
	} catch (InterruptedException e) {
	    e.printStackTrace();
	}

	System.out.println("③");
    }
}

Chapitre 9 Application de base de données JDBC

• ** L'API JDBC ** est standard dans JDK, ** le pilote JDBC ** varie en fonction de la base de données utilisée.
• Le format de l'URL de connexion à la base de données est Protocole: Nom du produit de la base de données // Détails de la connexion. jdbc: mysql: // localhost: 3306 / dbname Comme ça.
• Obtenez l'objet Connection avec la méthode getConnection de la classe DriverManager et obtenez l'objet Statement avec la méthode createStatement de l'objet Connection.
• L'objet Statement a les trois méthodes suivantes pour exécuter SQL.
• exécuter: CRUD Tout peut être exécuté. La valeur de retour est true si la valeur est obtenue par select, false dans le cas contraire.
• executeQuery: Seul SELECT peut être exécuté. La valeur de retour est ResultSet.
• executeUpdate: les instructions INSERT, UPDATE, DELETE ou DDL peuvent être exécutées. La valeur de retour est int comme le nombre de lignes mises à jour.

package tryAny.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcTest1 {
    public static void main(String[] args) {
	try (Connection c = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "test", "test");
		Statement stmt = c.createStatement()) {
	    ResultSet rs = stmt.executeQuery("SELECT * FROM personal;");
	    if (rs.absolute(4)) {
		System.out.println(rs.getString(2));
	    }

	    if (stmt.execute("SELECT * from personal")) {
		ResultSet rs2 = stmt.getResultSet();
		if (rs2.next()) {
		    System.out.println(rs2.getInt(1));
		}
	    }

	    System.out.println(stmt.executeUpdate("insert into personal values(6,'ccc','dddd')"));
	} catch (SQLException e) {
	    e.printStackTrace();
	}

    }
}

• Dans JDBC3.0, pour charger le pilote, il doit être explicitement décrit dans le programme comme suit. Le chargement explicite n'est plus requis dans JDBC 4.0.

Class.forName("com.mysql.jdbc.Driver");

• Si vous récupérez une fois un ResultSet à partir d'un objet Statement, puis que vous récupérez un autre ResultSet de la même Statement, le premier ResultSet obtenu sera fermé.

Chapitre 10 Localisation

• Le format du fichier de propriétés autorisé par java.util.Properties est un fichier texte ou un fichier XML.
• Pour lire le fichier de propriétés lui-même, utilisez FileInputSteam et passez le InputStream lu à l'argument de la méthode de chargement de l'objet Properties.

package tryAny.locale;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class LocaleTest1 {
    public static void main(String[] args) {

	try (InputStream is = new FileInputStream("test.properties");
		InputStream is2 = new FileInputStream("test2.properties")) {
	    Properties p = new Properties();
	    p.load(is);
	    p.list(System.out);
	    System.out.println("★" + p.getProperty("fruit") + "★");

	    //La charge ici n'est pas un écrasement, mais un ajout.
	    p.loadFromXML(is2);
	    p.forEach((k, v) -> System.out.println(k + "=" + v));
	    System.out.println("★" + p.getProperty("hoge") + "★");

	    /**
	     * -- listing properties --</br>
	     * fruit=apple</br>
	     * vegitable=carot</br>
	     * ★apple★</br>
	     * vegitable=carot</br>
	     * hoge=Hoge</br>
	     * fuga=Fuga</br>
	     * fruit=apple</br>
	     * piyo=Piyo</br>
	     *★ Hoge ★</br>
	     *
	     */
	} catch (IOException e) {
	    e.printStackTrace();
	}
    }
}

• En utilisant le mécanisme ResourceBundle, vous pouvez changer le fichier de propriétés à utiliser par Locale.

package tryAny.locale;

import java.util.Locale;
import java.util.ResourceBundle;

public class LocaleTest2 {
    public static void main(String[] args) {
	// test_ja_JP.fruit dans les propriétés=banana
	ResourceBundle rb1 = ResourceBundle.getBundle("test");
	System.out.println(rb1.getString("fruit"));// banana

	// test_en_US.fruit dans les propriétés=apple
	ResourceBundle rb2 = ResourceBundle.getBundle("test", Locale.US);
	System.out.println(rb2.getString("fruit"));// apple
    }
}

• Le code de langue utilisé pour la localisation est inférieur et le code de région est supérieur.
• Comment obtenir un objet Locale
• Constructeur: `Locale l = new Locale (" ja "," JP ");`
• Constante: Locale l = Locale.JAPAN; ``
• Utilisez getDefault: Locale l = Locale.getDefault ();
• Utiliser le constructeur

Locale.Builder b = new Locale.Builder();
b.setLanguage("cat");
b.setRegion("ES");
Locale l = b.build();

Sentiments divers après avoir passé l'examen

• Après avoir passé le test, j'ai réussi à réussir avec un taux de réponse correcte de 70%. C'était dangereux ...
• Pour l'apprentissage, le temps nécessaire a été enregistré avec une application de gestion du temps d'apprentissage appelée Studyplus. Le temps total consacré à l'apprentissage de Java Gold était de ** 36 heures **.
• Avant de passer l'examen, j'ai essayé un tour et deux questions de fin de chapitre tout en assemblant les chapitres 1 à 10. Ce que j'ai réellement ressenti quand je l'ai reçu
• API date / heure, Java / IO, application de base de données par JDBC, localisation, méthodes détaillées des classes traitées dans les chapitres environnants sont sortis fréquemment et j'étais frustré. J'ai senti qu'il serait préférable d'écrire le processus en utilisant ces méthodes une fois pour assurer l'acceptation. Cependant, il est impossible de supprimer toutes les méthodes, il est donc nécessaire de tracer une ligne quelque part. Dans le test réel, la méthode markSupported de BufferedReader est sortie, mais honnêtement, je n'en ai jamais entendu parler ...
• Le nombre de problèmes liés aux expressions Stream et lambda est anormalement élevé.
• J'ai l'impression que les questions ont été posées assez uniformément dans des domaines autres que Stream et Lambda.