Beschreiben Sie, was Sie in Java Gold zusammen mit der Java SE8 Gold-Problemsammlung (Kuromoto) gelernt haben.
Die hashCode-Methode für Objekte dient zur Verbesserung der Suchleistung.
Die Bedeutung des endgültigen Modifikators hängt von der Klasse, Variablen und Methode ab.
Klasse: Nicht vererbbar
Variable: Nicht neu zuweisbar, dh konstant
Methode: Kann nicht überschrieben werden
** Final kann dem Argument hinzugefügt werden ** (ich wusste nicht ...)
Code im statischen Initializer wird ausgeführt, wenn die Klasse geladen wird
Merkmale der Singleton-Klasse
Erstellen Sie eine eigene Instanz mit einem privaten statischen Feld
Deklarieren Sie den Konstruktor als privat
Bereiten Sie eine öffentliche statische Methode vor, die die im Feld festgelegte Instanz zurückgibt.
Über Diamantvererbung. Wenn eine Methode durch Mehrfachvererbung einer Schnittstelle überschrieben wird, tritt ein Kompilierungsfehler auf, wenn die Entfernungen gleich sind. Wenn jedoch die nächstgelegene Entfernung eindeutig bestimmt wird, wird die nächstgelegene übernommen.
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.Ausgabe
}
}
Es gibt eine verschachtelte Klasse. (Im Gegensatz dazu werden gewöhnliche Klassen als Klassen der obersten Ebene bezeichnet.)
statische Mitgliedsklasse, innere Klasse
Die äußere Klasse wird als einschließende Klasse bezeichnet. Die einschließende Klasse ist nicht unbedingt die Klasse der obersten Ebene.
Die Verwendung verschachtelter Klassen ist gemäß Perfect Java wie folgt
Wenn Sie ein Objekt nur innerhalb der umschließenden Klasse verwenden
Wenn Sie die Implementierung verschachtelter Klassen in der umschließenden Klasse ausblenden möchten
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();
}
}
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,Wird in der Reihenfolge 2 angezeigt
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,Anzeige in der Reihenfolge 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;
}
}
}
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);//Mann
}
public static void trans(Gender g) {
switch (g) {
case MAN:
System.out.println("Mann");
break;
case WOMAN:
System.out.println("Frau");
break;
case OTHER:
System.out.println("Andere");
break;
default:
assert (false);
}
}
}
Geben Sie Richtlinien für die Benennung von Variablen ein
In der Sammlung gespeicherte Elemente sind ** E **
Die in der Karte gespeicherten Schlüssel und Werte sind ** K ** bzw. ** V **.
Andere allgemeine Typen als die oben genannten sind ** T **
** R ** für Rückgabetyp
Der primitive Typ kann im Typargument nicht angegeben werden.
Die Variablendeklaration und das Typargument der Instanziierung müssen übereinstimmen. Daher ist es in JavaSE7 möglich, das Typargument bei der Instanziierung wie folgt wegzulassen.
Foo<Integer> foo = new Foo<>();
package tryAny.Generic;
public class GenericTest<T> {
/**
*Dies kann kompiliert werden, da T zum Zeitpunkt der Klassendeklaration und T in der folgenden Methode unterschiedlich sind.
*/
static <T> T exec3(T t) {
return t;
}
/**Folgendes wird nicht kompiliert
static T exec(T t) {
return t;
}
**/
}
//T ist auf den Subtyp Number beschränkt.
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>();//Kompilieren Sie durch
Hoge<Foo, Foo> h2 = new Hoge<Foo, Foo>();//Kompilieren Sie durch
// Hoge<Bar, Foo> h3 = new Hoge<Bar, Foo>();//Kompiliert nicht
}
}
abstract class Foo {
}
class Bar extends Foo {
}
class Hoge<T, U extends T> {
}
Sie können den Platzhalter verwenden **? ** Für Typargumente.
Beim Erben einer generischen Klasse muss die Typvariable festgelegt werden.
Vergleich von ArrayList und LinkedList
ArrayList hat schnellen Direktzugriff auf Elemente, aber die Kosten für das Hinzufügen von Elementen zur Liste sind hoch
LinkedList hat einen langsameren Direktzugriff als ArrayList, kostet jedoch weniger, um Elemente hinzuzufügen
ClassCastException wird ausgelöst, wenn das im TreeSet gespeicherte Element nicht vom Typ Comparable
Die Variable, die den Rückgabewert der Konstruktorreferenz erhält, muss eine funktionale Schnittstelle sein (was offensichtlich ist, wenn Sie darüber nachdenken).
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;
}
}
package tryAny.lambda;
public class LambdaTest {
public static void main(String[] args) {
Runnable r1 = new Runnable() {
public void run() {
System.out.println("run1");
}
};
//das Gleiche
Runnable r2 = () -> System.out.println("run2");
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
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"Die Anzahl der Zeichen von.
if (p.test(s.get())) {
c.accept(f.apply(s.get()).toString());
}
}
}
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);
}
}
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
}
}
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 + " ";
}
}
}
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();
}
}
}
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
}
}
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);
}
}
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}
}
}
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()Das Collector-Objekt, das von erstellt wurde</br>
*Sammeln Sie Eingabeelemente in der Liste.
*/
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;]
//Gruppieren Sie nach Anzahl der Zeichen
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]
*/
//Gruppe nach dem Akronym
Map<Character, List<String>> map2 = l.stream().collect(Collectors.groupingBy(e -> e.charAt(0)));
map2.forEach((v1, v2) -> System.out.println(v1 + ":" + v2));
}
}
package tryAny.lambda;
import java.util.function.IntFunction;
import java.util.function.ToIntFunction;
public class LambdaTest7 {
public static void main(String[] args) {
//Gibt das als Argument genommene int als Zeichen zurück
IntFunction<String> intFunc = String::valueOf;
//Gibt die Anzahl der Zeichen in der Zeichenfolge zurück, die als Argument verwendet wurden
ToIntFunction<String> toIntFunc = String::length;
System.out.println(intFunc.apply(11));
System.out.println(toIntFunc.applyAsInt("apple"));
}
}
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");
}
}
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);
}
}
}
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();← Nicht implementiert, da AutoCloseable nicht implementiert ist**/ ) {
//AutoCloseTest close wird ausgeführt.
} 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.");
}
}
package tryAny.exception;
public class ExceptionTest4 {
public static void main(String[] args) {
int x = 1;
assert (x == 2) : "Senden Sie eine Fehlermeldung!";
/**
*Im VM-Argument-Wenn ich ea eingebe, erhalte ich den folgenden Fehler.
*
* Exception in thread "main" java.lang.AssertionError:Senden Sie eine Fehlermeldung!
* at tryAny.exception.ExceptionTest4.main(ExceptionTest4.java:7)
*
*/
}
}
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);
}
}
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);//jetzt
System.out.println(ld2);//Vor einem Jahr
System.out.println(l);//Wenn Sie das Jahr der Saison nicht berücksichtigen-365
}
}
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
}
}
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()));
//Erstellen Sie Ihr eigenes Format
DateTimeFormatter dtf3 = DateTimeFormatter.ofPattern("yyyy★MM★dd");
System.out.println(dtf3.format(LocalDate.now()));
}
}
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 kann keine primitiven Typen wie boolean und double ausgeben.
pw.println(true);
pw.println(0.4);
} catch (FileNotFoundException e) {
System.out.println(e);
}
}
}
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 {
//Speichert serialisierte Daten.
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("iotest3.ser"))) {
String test = "iotest3";
oos.writeObject(test);//Das ist iotest3.Sie können ser.
oos.writeInt(111);
} catch (IOException e) {
throw new IOException(e);
}
//Holen Sie sich serialisierte Daten und erweitern Sie sie in den Speicher.
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);
}
}
}
Statische Variablen und Variablen mit dem Transientenmodifikator unterliegen keiner Serialisierung.
Java SE 7 hat die Klasse, die Dateien verarbeitet, von Datei in Pfad geändert, wodurch es möglich wird, den dateisystemspezifischen Mechanismus der Plattform transparent zu verwenden.
Das Standardverhalten der Files-Klasse ist wie folgt. Diese Verhaltensweisen können durch Angabe von Optionen in den Argumenten geändert werden.
Eine Ausnahme wird ausgelöst, wenn die Zieldatei vorhanden ist.
Die Attribute der Kopierquelldatei werden nicht vererbt.
Beim Kopieren eines Verzeichnisses werden die Dateien im Verzeichnis nicht kopiert.
Beim Kopieren eines symbolischen Links wird nur das Linkziel kopiert, nicht der Link selbst.
Klassen, die Dateiattribute verarbeiten, befinden sich im Paket java.nio.file.attribute und haben die folgenden drei.
BasicFileAttributes: Allgemeine Dateiattribute für Windows und Linux
DosFileAttributes: Windows-Dateiattribute
PosixFileAttributes: Linux-Dateiattribute
AttributeView ist eine Schnittstelle, die eine Reihe von Dateiattributen darstellt. (** Was bedeutet eine Reihe von Dateiattributen? **)
Wenn Sie ein einzelnes Attribut für eine Datei oder ein Verzeichnis erhalten möchten, können Sie Files.getAttribute verwenden.
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");
//Erstellungsdatum und -zeit
System.out.println((FileTime) Files.getAttribute(p, "creationTime"));
//Größe
System.out.println((long) Files.getAttribute(p, "size"));
//Ob es sich um eine symbolische Verbindung handelt
System.out.println((boolean) Files.getAttribute(p, "isSymbolicLink"));
}
}
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");
//Wenn eine Datei angezeigt wird, geben Sie sie standardmäßig aus.
Files.walkFileTree(p, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path path, BasicFileAttributes bfa) throws IOException {
System.out.println(path);
return FileVisitResult.CONTINUE;
}
});
//Geben Sie nur das Verzeichnis aus.
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);
}
}
Parallelitätsdienstprogramme werden in java.util.concurrent.atomic und java.util.concurrent.locks bereitgestellt. Der hier bereitgestellte Mechanismus und die Funktionen sind wie folgt.
Thread-Pool: Ein Mechanismus, um den Aufwand für die Thread-Erstellung zu vermeiden, indem Threads im Voraus erstellt und gespeichert werden. Das Executor Framework bietet diese Funktionalität
Parallele Sammlung: Eine Sammlung, die ein ausgewogenes Verhältnis zwischen Leistung und Parallelität herstellt.
Atomvariable: Eine Variable, die die Atomizität der Verarbeitung garantiert, dh ein Mechanismus, der garantiert, dass es keine andere Situation geben kann als die Wahl, eine bestimmte Funktion auszuführen oder nicht auszuführen. Wenn es sich um einen Inkrementierungsprozess handelt, handelt es sich um einen Prozess zum (1) Lesen des Werts → (2) Ändern des Werts → (3) Schreiben des Werts, aber es wird garantiert, dass der Fluss von (1) nach (3) entweder abgeschlossen oder unberührt ist. (Es wird davon ausgegangen, dass andere Verarbeitungen zwischen ① und ② in die Zielvariable schreiben.)
Semapho zählen: ** Semafo ** ist ein Mechanismus zur Synchronisation und Interrupt-Steuerung zwischen Prozessen und Threads. Es gibt ** binäre Semaphos ** und ** Zählsemafos **. Im binären Semapho sind die Arten der Zugriffskontrolle für Ressourcen nur "möglich" und "unmöglich", während im Zählsemapho die Anzahl der zugänglichen Ressourcen beliebig eingestellt werden kann.
Atomvariablen garantieren den atomaren Betrieb.
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();
//Es wird definitiv 200.000 sein.
mac.show();
}
}
class MyAtomCounter {
private AtomicInteger count = new AtomicInteger();
public void increment() {
count.incrementAndGet();
}
public void show() {
System.out.println("Für 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();
}
}
}
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,Teil 3 ist möglicherweise nicht der Fall. 1,2,Es ist wie 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();
}
}
}
package tryAny.concurrentUtility;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
//Generiert weiterhin jede Sekunde zufällige Werte.
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;
}
}
}
}
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("③");
}
}
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();
}
}
}
Class.forName("com.mysql.jdbc.Driver");
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") + "★");
//Die Last ist hier kein Überschreiben, sondern eine Ergänzung.
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();
}
}
}
package tryAny.locale;
import java.util.Locale;
import java.util.ResourceBundle;
public class LocaleTest2 {
public static void main(String[] args) {
// test_ja_JP.Obst in Eigenschaften=banana
ResourceBundle rb1 = ResourceBundle.getBundle("test");
System.out.println(rb1.getString("fruit"));// banana
// test_en_US.Obst in Eigenschaften=apple
ResourceBundle rb2 = ResourceBundle.getBundle("test", Locale.US);
System.out.println(rb2.getString("fruit"));// apple
}
}
`Gebietsschema l = neues Gebietsschema (" ja "," JP ");``Gebietsschema l = Locale.JAPAN;``Locale l = Locale.getDefault ();`Locale.Builder b = new Locale.Builder();
b.setLanguage("cat");
b.setRegion("ES");
Locale l = b.build();
Recommended Posts