Grammaire de base Java

type

Concernant le type

Les types tels que int et long sont appelés type de base, type valeur et type primitif.
Les types tels que String et Integer sont appelés types de référence, types d'objet et classes wrapper.
Les types de référence sont ensuite divisés en immuables et mutables.
La plupart d'entre eux sont mutables et String, LocalDate et LocalDateTime sont reconnus comme immuables.
Immutable ne peut pas modifier la valeur directement et doit être réaffecté.

Concernant la conversion de type

graph LR
    byte-->short
    short-->int
    char-->int
    int-->long
    long-->float
    float-->double

Typecast est nécessaire pour convertir de droite à gauche. Exemple: int a = (nom du type) b
Conversion de type implicite de gauche à droite
La conversion de type du type primitif en classe wrapper est appelée autoboxing, et vice versa s'appelle unboxing → lien

Variables et constantes

Déclaration


/*Déclaration de variable*/
boolean varA; //Déclaration uniquement
varA = true; //Substitution uniquement
Class varI //Déclaration uniquement(Type de référence)
varI = new Class() //Substitution uniquement(Type de référence) 

/*Déclaration constante*/
static final data_type varJ = valA; // (static + )modificateur final

Tableau

Tableau de longueur fixe

/*Déclaration*/
data_typeA[] arrayA = new data_typeA[index_max_value];
data_typeB[] arrayB = {valA, valB, valC, valD, valE};
data_typeC[] arrayC = new data_typeC[] {valF, valG, valH};
data_typeD arrayD[]; //Dans le nom de la variable[]Peut être attaché
// X arrayD = {valI, valJ, varl}
arrayD = new data_typeD[]{valI, valJ, varl}
data_type[][] arrayE; //Tableau 2D → date_type[] arrayE[]C'est possible.
arrayE = new date_typeE[i][]; //Le deuxième indice peut être omis. Le premier n'est pas possible.

/*classe de tableaux*/
Arrays.toString(arrayD); // "[valI, valJ, vall]"
Arrays.sort(arrayD);     // {vall, valJ, valI}

Tableau de longueur variable (collection)

/* List(interface) */
// X List<data_typeA> listA = new List<>();
List<data_typeA> listA =  new ArrayList<>();
List<data_typeB> listB =  new LinkedList<>();
List<data_typeC> listC =  new CopyOnWriteArrayList<>();
List<data_typeD> listD = Arrays.asList(valA, valB); //Lecture seule
listD.add(valD);         //Ajouter à la fin
listD.add(indexA, valE); //Insérer au milieu
listD.set(indexA, valF); //Remplacement
listD.get(indexA);       //Obtenez de la valeur
listD.indexOf(valF);     //Obtenir la position
listD.size();            //Obtenez le nombre d'éléments
listD.contains(valF);    //Confirmation d'existence
listD.remove(valF);      //Effacer

/* ---Voici la classe d'implémentation de List------------------------------- */
/* ArrayList ..Fort en recherche*/
//Si vous souhaitez utiliser une méthode qui n'existe que dans ArrayList, déclarez-la ci-dessous.(La même chose s'applique ci-dessous)
ArrayList<data_typeE> listE =  new ArrayList<>();
ArrayList listF = (ArrayList<data_typeE>)listE.clone(); //copie

/* LinkedList ..ajouter à/Fort contre la suppression*/
LinkedList<data_typeG> listG =  new LinkedList<>();
listG.push(); //Ajouter au début
listG.pop();  //Supprimer depuis le début

/* CopyOnWriteArrayList ..Aucune synchronisation requise/Fort contre le multithreading*/
CopyOnWriteArrayList<data_typeH> listH =  new CopyOnWriteArrayList<>();

Tableau associatif (collection)

/* Map(interface) */
// X Map<Integer, data_typeA> mapA = new Map<>();
Map<Integer, data_typeA> mapA = new HashMap<>();
Map<Integer, data_typeB> mapB = new LinkedHashMap<>();
Map<Integer, data_typeC> mapC = new ConcurrentHashMap<>();
Map<Integer, data_typeD> mapD = new TreeMap<>();

mapA.put(keyA, valA);     //Ajouter à la fin
mapA.put(keyA, valB);     //Remplacement
mapA.get(keyA);           //Obtenez de la valeur
mapA.size();              //Obtenez le nombre d'éléments
mapA.containsKey(keyA);   //Recherche clé
mapA.containsValue(valB); //Recherche de valeur
mapA.remove(keyA);        //Effacer

/* ---Mappez la classe d'implémentation ci-dessous------------------------------- */
/* HashMap ...Fort en recherche*/
HashMap<Integer, data_typeE> mapE = new HashMap<>();

/* LinkedHashMap ..Gardez l'ordre d'insertion*/
LinkedHashMap<Integer, data_typeF> mapF = new LinkedHashMap<>();

/* ConcurrentHashMap ..Aucune synchronisation requise/Fort contre le multithreading*/
ConcurrentHashMap<Integer, data_typeG> mapG = new ConcurrentHashMap<>();

/* TreeMap ..Sous-ensemble conscient de la taille de la clé*/
TreeMap<Integer, data_typeH> mapH = new TreeMap<>();

Ensemble (Collection)

// X Set<data_typeA> setA =  new Set<>();
Set<data_typeA> setA =  new HashSet<>();
Set<data_typeB> setB =  new LinkedHashSet<>();
Set<data_typeC> setC =  new TreeSet<>();
Set<data_typeD> setD =  new HashSet<>(ListA); // List->Set

setD.add(valA);      //Ajouter de la valeur/Écraser
setD.remove(valB);   //Supprimer la valeur
setD.size();         //Obtenez le nombre d'éléments
setD.contains(valC); //Recherche de valeur

/* ---La classe d'implémentation Set suivante------------------------------- */
/* HashSet ..Fort en recherche*/
HashSet<data_typeA> setA =  new HashSet<>();

/* LinkedHashSet ..ajouter à/Fort contre la suppression*/
LinkedHashSet<data_typeB> setB =  new LinkedHashSet<>();

/* TreeSet ..Sous-ensemble conscient de la taille de la clé*/
TreeSet<data_typeC> setC =  new TreeSet<>();

Autre

File d'attente et sa mise en œuvre ... FIFO

Queue<data_typeA> queueA = new ArrayBlockingQueue<>(intA);
queueA.offer(valA); //ajouter à
queueA.peek();      //production
queueA.poll();      //production/Effacer

Deque et son implémentation ... Une extension de Queue. Peut être ajouté ou supprimé des deux côtés.

//LinkedList est une implémentation de List et Deque
Deque<data_typeA> dequeA = new LinkedList<>();
dequeA.offerFirst(valA); //Ajouter de la valeur au début
dequeA.offerLast(valB);  //Ajouter de la valeur à la fin
dequeA.peekFirst(valC);  //Sortie de la première valeur
dequeA.peekLast(valD);   //Sortie de la valeur de fin
dequeA.pollFirst(valE);  //Sortie de la première valeur/Effacer
dequeA.pollLast(valF);   //Sortie de la valeur de fin/Effacer

Référence: [Java] Mémo de la file d'attente de la pile

Branche

Si déclaration


if (conditionA){ 
    statementA //Relevé, traitement
} else if (conditionB) {
    statementB //Relevé, traitement
} else if (!conditionC) {
    statementC //Relevé, traitement
} else {
    statementD //Relevé, traitement
}

/* {}réduction...Une seule ligne peut être écrite dans le nid*/
if (conditionA)
    statementA //Relevé, traitement
else
    statementB //Relevé, traitement

instruction switch


switch (varA) {
    case valA:     // varA =Pour valA
        statementA //Relevé, traitement
        //déclaration break...Fin de l'exécution du bloc de code
        break;
    case valB:
    case valC:     // varA = valB,Pour valC
        statementB //Relevé, traitement
        break;
    case default   // varA = valA,valB,Autre que valC
        statementC //Relevé, traitement
        break;
	/*Il n'y a pas de limite à l'ordre des affaires. la valeur par défaut peut être au début(non recommandé) */
}

Itératif

Pour déclaration

/*Répétez la phrase un certain nombre de fois*/
for (data_type varA = valA; varA <= valB; valC++) {
    statementA //Relevé, traitement
}
/* for(int a, int b, a < 3, a++, method()){comme
Plusieurs valeurs initiales et valeurs de mise à jour peuvent être définies. La valeur mise à jour peut également être appelée une méthode) */

/*Répéter à partir de la collection de tableaux*/
for (data_type varB : collectionA) {
    statementB //Relevé, traitement
}

/*Combinaison de for Each et expression lambda(Sortir les éléments de collectionB) */
collectionB.forEach(varC -> System.out.println(varC));

Instruction While (instruction Do-While)

/*Répéter tant que l'expression conditionnelle est vraie*/
while (conditionA) {
    statementA //Relevé, traitement
} 

do { 
    statementB //Relevé, traitement
} while (conditionB);

/*Lors de la répétition jusqu'à ce que l'expression conditionnelle devienne True*/
while (!conditionC){
    statementC //Relevé, traitement
}

do { 
    statementD //Relevé, traitement
} while (conditionD);

Instructions Break and Continue

X: //étiquette
while (conditionA) {
    switch(varA){
        case valA: // statementA,Passer par B
            statementA //Relevé, traitement
        case valB: //Seule l'instruction B réussit
            statementB //Relevé, traitement
            /*déclaration break...Fin de l'exécution du bloc de code*/
            break;
		case valC:
		    break X; //1ère ligne "X:Sauter à(Quitter pendant)
        default:
            statementC //Relevé, traitement
            /*continue déclaration...Déplacer le contrôle d'exécution vers l'itération suivante*/
            continue;
    } 
}

Gestion des exceptions ... Rechercher les erreurs

/* try ...Traitement cible*/
try{
	statementA
/* catch ...Gestion des exceptions*/
} catch (xxxException e){
	e.printStackTrace();    //Message d'exception(Basique ceci)
	e.getClass().getName(); //Nom de classe d'exception uniquement
	e.getMessage();         //Message de détail d'exception uniquement
	StackTraceElement[] ste = e.getStackTrace(); //Liste des exceptions
/* finally ... try/Après la capture(try/Même s'il y a un retour dans la capture)Un processus qui doit être exécuté.*/
} finally{
	statementB //Relevé, traitement
}
// try-catch-L'ordre de finalement ne peut pas être modifié. essayer-catch, try-Facultatif comme enfin.

/*clause throw...Génération forcée d'exceptions*/
throw new ExceptionClassA();

/*clause throws...Transmettre l'erreur à l'appelant*/
public class Main throws Exception { //Si vous l'attachez à main, il y aura quelques exceptions

Type d'exception

classe	Aperçu	Moment de l'événement
Error	Erreurs qui ne peuvent pas être traitées par le programme, telles que des problèmes dans l'environnement d'exécution	Durée(Élément sans inspection)
Exception - RuntimeException	Exception qui peut être évitée si le programme est écrit correctement	Durée(Élément sans inspection)
Exception -Autre que ceux ci-dessus	Exception qui ne peut être évitée même si le programme est correctement écrit. lancers requis	Au moment de la compilation(Article d'inspection)

classe

Principes de base du cours

package	scope1.packageA;   //Déclaration de colis
import scopeB.libC;        //Importer la libC d'un autre package B
import static scopeC.libD.methodA; //Importation statique de méthode Une méthode de libD d'un autre package C

public class ClassA{
    /*Méthode appelée au début*/
	//Autres modèles d'argument pour main(String... args), (String args[])
	public static void main(String[] args){
		ClassB instanceA = new ClassB("naiyo");
		System.out.println(instanceA.getMethodA());
	}
}

private class ClassB{
	private data_type _fieldA;
    
	/*initialiseur statique...Accès statique, instanciation, etc.
Première exécution lorsque la classe est chargée pour la première fois*/
	static {
        //Processus d'initialisation, etc.
	}

	/*Bloc d'initialisation...Première exécution à chaque fois qu'une instance est créée*/
	{
		//Processus d'initialisation, etc.
	}

	/*constructeur...Première exécution à chaque fois qu'une instance est créée*/
	Class2(){
        this._fieldA = "";
    }

    /*L'ordre est un initialiseur statique->Bloc d'initialisation->constructeur*/

    /*Setter*/
	data_type setMethodA(data_type varB){
		this._fieldA = varB; //L'argument et le nom du champ sont identiques
	}

    /*Getter*/
	data_type getMethodA(){
		return this._fieldA;
	}
}

Modificateur

/*Modificateur d'accès*/
private class1{}         //Uniquement accessible à partir de la même classe
protected class class1{} //Uniquement de la même classe et sous-classe
class class1{}           //Seulement à partir du même paquet
public class class1{}    //De toutes les classes

/*Autres modificateurs*/
abstract      //Classe abstraite, méthode abstraite
static        //nom de la classe.Peut être appelé par un membre,Inaccessible aux membres non statiques
final         //Ne sera pas écrasé(constant)
synchronized  //Contrôle exclusif pour plusieurs processus
native        //Classe native, méthode native
strictfp      //Calculer des nombres à virgule flottante selon IEEE754
transient     //Exclus de la sérialisation
volatile      //Supprimer la mise en cache des valeurs de champ
const         //Modificateur de constante multilingue, non utilisé en Java

/*Annotation*/
@Deprecated       //Clarifié comme obsolète
@Override         //Précisez que vous écrasez
@SuppressWarning  //Supprimer l'affichage d'avertissement

/*Commande*/
@Annotation 
public protected private
abstract static final synchronized native strictfp

Héritage (polymorphisme)

Bases de l'héritage

/*Classe parent*/
protected class ClassA{
	protected data_type fieldA;
	protected Class1(data_type varA){　//Constructeur de classe parent
        this.fieldA = varA;
    }  
	protected void methodA(data_type varB){　//Méthode de classe parent
        statementA
    } 
}

/*Classe enfant*/
public class ClassB extends ClassA{
	public ClassB(data_type varC){ //Constructeur de classe enfant
		super(varC); //Appelez le constructeur de classe parent
	}
	@Override //Modifier le modificateur(Comme mentionné ci-dessus)
	public void methodA(data_type var2){
    	statementB //Relevé, traitement
	}
}

Classe abstraite ... Je souhaite implémenter un modèle et un traitement commun

/*Classe abstraite*/
protected abstract class ClassA{
	protected data_type fieldA;
	public Class1(data_type varA){
		this.fieldA = varA
	}
	//Méthode prérequise à remplacer(Méthode abstraite)
	public abstract void methodA(data_type varB); 
}
/*Classe enfant*/
protected abstract class ClassB{
	@Override
	public abstract void methodA(data_type varB){
    	statementA //Relevé, traitement
	}
}

Interface ... Seules les méthodes abstraites et les constantes peuvent être définies (principe)

/*interface*/
public interface InterfaceA{
	/*Fondamentalement, les types sont répertoriés comme suit.*/
	data_type CONST_A = "CONST_A"; //public static final est facultatif
	data_type methodA(data_type varA);

	/* ----Ajouté à partir de Java 8 ci-dessous. Personnellement obsolète(Parce que c'est compliqué) ---- */
	//méthode par défaut...Quelque chose comme une méthode régulière d'une classe abstraite
	default void methodB(data_type varB){
    	statementA //Relevé, traitement
	}
	//méthode statique...Peut être appelé sans instance
	public static methodC(data_type varC){
    	statementB //Relevé, traitement
	}
}

/*Classe enfant*/
public class ClassB extends InterfaceA{
	public static void main(String[] args){		
		@Override
		public static methodB(data_type varB){
			// Ｘ ClassB.methodC
			// Ｘ @Override methodC
			InterfaceA.methodC(Interface1.CONST_A);
		}
}

Différentes classes

Classe génériques (modèle)

public class GenericClassA<TYPE>{
	private TYPE _fieldA;
	GenericClassA(TYPE varA){
		this._fieldA = varA;
	}
	TYPE setMethodA(TYPE varB){
		this._fieldA = varB;
	}
	TYPE getMethodA(){
		return this._fieldA;
	}
}

/*Méthode générique*/
public class ClassA{
	public static <TYPE> ArrayList<TYPE> GenericMethodA(TYPE val1){
	}
}

Classe intérieure

public class ClassA{
	/*classe de membre statique... */
	static class MemberClassA{}

	/*Classe de membre non statique... */
	class MemberClassB{}

	public static void main(String[] args) {
		/*Classe locale... */
		class LocalClassC{
			public void localMethod(){}
		}
		LocalClassC localClassC = new LocalClassC();
		localClassC.localMethod();

		/*Classe anonyme...Peut être défini et instancié en même temps*/
		//Classe anonyme qui hérite du type ArrayList
		List<data_typeC> list = new ArrayList<data_typeC>() {
			public data_typeC method3() {
				statements //Relevé, traitement
			}
		};
	}
}

public class ClassB{
	public static void main(String[] args){
		//appel de classe de membre statique
		ClassA.MemberClassA cAcA = new ClassA.MemberClassA();
		//Appel de classe de membre non statique
		ClassA cA = new ClassA();
		ClassA.MemberClassB cAcB = cA.new MemberClassB();
	}
}

Module (Java 9)

`module-info.java`


module moduleA{ // module-info.Décrit dans un fichier appelé java.
    export moduleA.lib; //Publiez la bibliothèque dans ce module
    requires moduleB;   //Décrivez les modules requis par ce module
}

Référence: Apprendre le système de modules / Modules Java

enum (type d'énumération)

public enum EnumA{
	/*De base*/
	elmA, elmB;
	/*application-Ajouter des membres, des variables et des méthodes*/
	elmC(0), elmD(1);
	private final int fieldA;
	private setElmA(int varA){
        this.fieldA = varA;
    }
	public int getVal(){
        return fieldA;
    }
	public void outVal(){ // values() ..Liste de tous les éléments d'énumération
		for (Enum2 enums : values()) { 
			System.out.println(enums.getVal()); // 0, 1
		}
	}
}

Expression Lambda (Java 8)

Comment écrire

/* (args) -> { statements //Relevé, traitement} */
//Dans un cas, args-> statements
Collections.sort(listA, (a,b) -> {return b - a;});

Référence de la méthode

/*Méthode statique(class::method)*/
// list.forEach(i -> String.toString(i)));
list.forEach(String::toString);

/*Méthode membre(this::method) */
// list.forEach(i -> this.toString(i)));
list.forEach(this::toString);

/*Méthode générique(class::<type> method) */
// list.forEach(i -> ClassA<typeA> methodA(i);));
list.forEach(ClassA::<typeA> methodA);

/*Méthode d'instance(object::method) */
// list.forEach(i -> System.out.print(i));
list.forEach(System.out::print);

/*constructeur(class::new) */
ClassA instanceA = classA::new;

Interface de type de fonction
... Si une seule méthode abstraite est définie, etc., elle peut être affectée à une expression lambda ou à une référence de méthode.

@FunctionalInterface
public interface FuncInterfaceA {
	public data_typeA method(data_typeA varA);
}

/*Interface fonctionnelle standard majeure*/
// Function.apply()Convertir la valeur
Function<String, Integer> func = x -> x.length();
System.out.println(func.apply("mojisu")); // 6

// Predicate.test()Faire un jugement
Predicate<Integer> condA = i -> i != 0 ;
Predicate<Integer> condB = i -> i % 2 == 0 ;
condA.test(2);            // true
condA.negate().test(1);   // false (negate..le déni)
condA.or(condB).test(1);  // true  (ou jugement)
condA.and(condB).test(1); // false (et jugement)

// Supplier.get()Renvoie une valeur sans argument
Supplier nowTime = () ->  LocalDateTime.now();
System.out.println(nowTime.get()); // 2020-01-22 12:34:56

// Consumer.accept()Processus basé sur des arguments
Consumer<String> printA = str -> {
	System.out.println("printA: " + str);
}
Consumer<String> printA = str -> {
	System.out.println("printB: " + str);
}
Consumer<String> printAll = printA.andThen(printB); //Joindre
printAll.accept("" + System.currentTimeMillis());

Référence: Understanding Java 8 lambda expressions / [interface fonctionnelle Java](http://www.ne.jp/asahi/hishidama/home/ tech / java / Functionalinterface.html)

API de flux (Java 8)

//Générer un flux
Stream<data_typeA> streamA = listA.stream(); // stream()Mettez
IntStream intStreamA = IntStream.range(1,5); //Créer un flux à partir de nombres
//Fonctionnement intermédiaire
streamA.filter(p -> p.length() > 5); //Rétrécir
streamA.map(p -> "[" + p + "]"); //remplacer
//Opération de terminaison
List<data_typeB> listB = streamA.collect(Collectors.toList()); //conversion
//production
listB.forEach(System.out::println);

/*Bon mot*/
listA.stream()
	.filter(p -> p.length() > 5)
	.map(p -> "[" + p + "]")
	.collect(Collectors.toList())
	.forEach(System.out::println);

Méthode de fonctionnement intermédiaire

Méthode	Traitement du contenu	Exemple
map	Remplacer l'élément par une autre valeur	.map(s-> s.getMethod())
flatmap	Combinez des flux d'éléments	.flatmap(s -> s2.stream())
filter	Affiner les éléments correspondants	.filter(s -> s.equals(1)
limit	Limiter au nombre spécifié	.limit(2)
distinct	Limitez-vous aux éléments uniques	.distinct()
sorted	Trier les éléments	.sorted((s1,s2) -> s2-s1)
range	Créer une colonne numérique sans inclure la dernière valeur	IntStream.range(1,5)
rangeClosed	Créer une séquence de nombres comprenant la dernière valeur	IntStream.rangeClosed(1,5)

Méthode d'opération de terminaison

Méthode	Traitement du contenu	Exemple
forEach	Répéter	.forEach(System.out::println);
collect	Créer des résultats	.collect(Collectors.toList());
toArray	Convertir en tableau	.toArray(String[]::new);
reduce	Valeurs agrégées	.reduce((val1,val2) -> val1.add(val2));
toList	Retourner comme liste	.collect(Collectors.toList());
toSet	Retourner comme ensemble	.collect(Collectors.toSet());
joining	Combiner avec un délimiteur	.collect(Collectors.joining(","));
groupingBy	Éléments de groupe	.collect(Collectors.groupingBy(s -> s.length()));

Ceci n'est qu'un mémo, veuillez donc comprendre qu'il peut y avoir des erreurs.

Grammaire de base Java

** type **

Concernant le type

Concernant la conversion de type

Variables et constantes

** Déclaration **

Tableau

** Tableau de longueur fixe **

** Tableau de longueur variable (collection) **

** Tableau associatif (collection) **

** Ensemble (Collection) **

Autre

File d'attente et sa mise en œuvre ... FIFO

Deque et son implémentation ... Une extension de Queue. Peut être ajouté ou supprimé des deux côtés.

Branche

** Si déclaration **

** instruction switch **

Itératif

** Pour déclaration **

** Instruction While (instruction Do-While) **

** Instructions Break and Continue **

Gestion des exceptions ... Rechercher les erreurs

Type d'exception

classe

** Principes de base du cours **

** Modificateur **

** Héritage (polymorphisme) **

** Bases de l'héritage **

Classe abstraite ... Je souhaite implémenter un modèle et un traitement commun

Interface ... Seules les méthodes abstraites et les constantes peuvent être définies (principe)

** Différentes classes **

** Classe génériques (modèle) **

** Classe intérieure **

** Module (Java 9) **

module-info.java

enum (type d'énumération)

** Expression Lambda (Java 8) **

Comment écrire

Référence de la méthode

Interface de type de fonction ... Si une seule méthode abstraite est définie, etc., elle peut être affectée à une expression lambda ou à une référence de méthode.

** API de flux (Java 8) **

Méthode de fonctionnement intermédiaire

Méthode d'opération de terminaison

type

Déclaration

Tableau de longueur fixe

Tableau de longueur variable (collection)

Tableau associatif (collection)

Ensemble (Collection)

Si déclaration

instruction switch

Pour déclaration

Instruction While (instruction Do-While)

Instructions Break and Continue

Principes de base du cours

Modificateur

Héritage (polymorphisme)

Bases de l'héritage

Différentes classes

Classe génériques (modèle)

Classe intérieure

Module (Java 9)

`module-info.java`

Expression Lambda (Java 8)

Interface de type de fonction
... Si une seule méthode abstraite est définie, etc., elle peut être affectée à une expression lambda ou à une référence de méthode.

API de flux (Java 8)