dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
	testImplementation 'org.springframework.boot:spring-boot-starter-data-mongodb-test'
    // 他省略
}

spring.mongodb.uri=mongodb://localhost:27017/demo?directConnection=true

package com.example.demo.models;

import java.time.LocalDateTime;
import org.springframework.data.mongodb.core.mapping.Document;
import lombok.Data;

// ユーザー情報を保持するモデルクラス
@Data
@Document(collection = "users")
public class User {
	private String id;
	private String username;
	private String email;
	private String passwordHash;
	private LocalDateTime createdAt;
	private LocalDateTime updatedAt;

	public User() {
		this.createdAt = LocalDateTime.now();
		this.updatedAt = this.createdAt;
	}

	public User(String username) {
		this.username = username;
		this.createdAt = LocalDateTime.now();
		this.updatedAt = this.createdAt;
	}
}

package com.example.demo.repository;

import java.util.List;
import com.example.demo.models.User;
import org.springframework.data.mongodb.repository.MongoRepository;

public interface UserRepository extends MongoRepository<User, String> {
  public List<User> findByUsername(String username);
}

package com.example.demo;

import com.example.demo.models.User;
import com.example.demo.repository.UserRepository;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping("/hello")
    public String hello() {
        // ユーザーコレクションをクリアしてから新しいユーザーを保存
        userRepository.deleteAll();
        userRepository.save(new User("n-ozawan"));

        // "n-ozawan" というユーザー名でユーザーを検索
        List<User> users = userRepository.findByUsername("n-ozawan");

        // 検索結果を文字列に変換して返す
        return users.stream()
                .map(User::toString)
                .collect(Collectors.joining(", "));
    }
}

[
  {
    _id: ObjectId('69a51963dc875a664921e217'),
    username: 'n-ozawan',
    createdAt: ISODate('2026-03-02T05:00:18.977Z'),
    updatedAt: ISODate('2026-03-02T05:00:18.977Z'),
    _class: 'com.example.demo.models.User'
  }
]

package com.example.demo;

import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.bson.Document;
import org.springframework.data.mongodb.core.query.Query;
import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Query.query;

@RestController
public class Hello2Controller {

    @Autowired
    private MongoTemplate mongoTemplate;

    @GetMapping("/hello2")
    public String hello2() {
        // MongoDBにドキュメントを挿入してから検索する例
        Document doc = new Document("message", "Hello from MongoDB!")
            .append("hoge", new Document("fuga", 123));

        // コレクションを一旦クリアしてから新しいドキュメントを挿入
        mongoTemplate.dropCollection("greetings");
        mongoTemplate.insert(doc, "greetings");

        // "message" フィールドが "Hello from MongoDB!" であるドキュメントを検索
        Query query = query(where("message").is("Hello from MongoDB!"));
        query.fields().include("message").exclude("_id");
        List<Document> documents = mongoTemplate.query(Document.class)
                .inCollection("greetings")
                .matching(query).all();

        // 検索結果を文字列に変換して返す
        return documents.stream()
                .map(Document::toJson)
                .collect(Collectors.joining(", "));
    }
}

Runnable runner = new Runnable() {
  @Override
  public void run() {
    System.out.println("Hello, World!");
  }
};

runner.run();

Runnable runner = () -> System.out.println("Hello, World!");
runner.run();

interface FunctionalInterfaceExample {
  void run(String message);
}

FunctionalInterfaceExample example = (message) -> System.out.println(message);
example.run("Hello, Functional Interface!");

interface FunctionalInterfaceExample {
  void run(String message);
  void hoge();
}

FunctionalInterfaceExample example = (message) -> System.out.println(message);
example.run("Hello, Functional Interface!");

// main.java:24: error: incompatible types: FunctionalInterfaceExample is not a functional interface
//     FunctionalInterfaceExample example = (message) -> {
//                                          ^
//     multiple non-overriding abstract methods found in interface FunctionalInterfaceExample
// 1 error
// error: compilation failed

@FunctionalInterface
interface FunctionalInterfaceExample {
  void run(String message);
}

Function<String, Integer> stringLengthFunction = (str) -> str.length() * 10;
int length = stringLengthFunction.apply("Hello");
System.out.println("Length: " + length);    // Outputs: Length: 50

Consumer<String> printer = (message) -> System.out.println(message);
printer.accept("Hello, Consumer!");     // Outputs: Hello, Consumer!

Predicate<String> isHello = (str) -> str != null && str.equals("hello");
System.out.println(isHello.test("hello"));  // Outputs: true
System.out.println(isHello.test(null));     // Outputs: false

Supplier<Double> randomSupplier = () -> Math.random();
System.out.println("Random number: " + randomSupplier.get());

String[] names = {"佐藤", "鈴木", "高橋", "田中", "伊藤", "伊藤"};

// List型に変換
List<String> nameList = Arrays.stream(names).collect(Collectors.toList());
IO.println(nameList);   // [佐藤, 鈴木, 高橋, 田中, 伊藤, 伊藤]

// Set型に変換
Set<String> nameSet = Arrays.stream(names).collect(Collectors.toSet());
IO.println(nameSet);    // [佐藤, 鈴木, 高橋, 田中, 伊藤]

// 任意のCollection型に変換
Deque<String> nameDeque = Arrays.stream(names).collect(Collectors.toCollection(ArrayDeque::new));
IO.println(nameDeque);  // [佐藤, 鈴木, 高橋, 田中, 伊藤, 伊藤]

Person[] people = {
  new Person("ID1", "佐藤"),
  new Person("ID2", "鈴木"),
  new Person("ID3", "高橋"),
  new Person("ID4", "田中"),
  new Person("ID5", "伊藤")
};

// IDをキー、Personオブジェクトを値とするMapに変換
Map<String, Person> idToPersonMap = Arrays.stream(people)
  .collect(Collectors.toMap(Person::getId, person -> person));
IO.println(idToPersonMap);  // {ID1=Person@1a2b3c4, ID2=Person@5d6e7f8, ID3=Person@9a0b1c2, ID4=Person@3d4e5f6, ID5=Person@7a8b9c0}

// IDをキー、名前を値とするMapに変換
Map<String, String> idToNameMap = Arrays.stream(people)
  .collect(Collectors.toMap(Person::getId, Person::getName));
IO.println(idToNameMap);  // {ID1=佐藤, ID2=鈴木, ID3=高橋, ID4=田中, ID5=伊藤}

Person[] people = {
  new Person("佐藤", 28),
  new Person("鈴木", 34),
  new Person("高橋", 22),
  new Person("田中", 40),
  new Person("伊藤", 30)
};

// 区切り文字なしで連結
String result1 = Arrays.stream(people).map(Person::getName)
  .collect(Collectors.joining());
IO.println(result1);  // 佐藤鈴木高橋田中伊藤

// 区切り文字ありで連結
String result2 = Arrays.stream(people).map(Person::getName)
  .collect(Collectors.joining(", "));
IO.println(result2);  // 佐藤, 鈴木, 高橋, 田中, 伊藤

// 接頭辞?接尾辞ありで連結
String result3 = Arrays.stream(people).map(Person::getName)
  .collect(Collectors.joining(", ", "★開始★, ", ", ★終了★"));
IO.println(result3);  // ★開始★, 佐藤, 鈴木, 高橋, 田中, 伊藤, ★終了★

Person[] people = {
  new Person("佐藤", 28),
  new Person("鈴木", 34),
  new Person("高橋", 22),
  new Person("田中", 40),
  new Person("伊藤", 30)
};

// 平均年齢
double averageAge = Arrays.stream(people)
  .collect(Collectors.averagingInt(Person::getAge));
IO.println(averageAge);  // 30.8

// 最年長
int maxAge = Arrays.stream(people)
  .collect(Collectors.summarizingInt(Person::getAge))
  .getMax();
IO.println(maxAge);      // 40

// 一括集計 (個数、合計、最小、平均、最大)
IntSummaryStatistics ageStats = Arrays.stream(people)
  .collect(Collectors.summarizingInt(Person::getAge));
IO.println(ageStats);    // IntSummaryStatistics{count=5, sum=154, min=22, average=30.800000, max=40

Person[] people = {
  new Person("佐藤", 28, "営業"),
  new Person("鈴木", 34, "開発"),
  new Person("高橋", 22, "営業"),
  new Person("田中", 40, "開発"),
  new Person("伊藤", 30, "総務")
};

// 部署ごとにグルーピング
Map<String, List<Person>> groupedByDepartment = Arrays.stream(people)
  .collect(Collectors.groupingBy(Person::getDepartment));
IO.println(groupedByDepartment);          // {営業=[Person@1a2b3c4, Person@5d6e7f8], 開発=[Person@9a0b1c2, Person@3d4e5f6], 総務=[Person@7a8b9c0]}
IO.println(groupedByDepartment.get("営業").get(0).getName());  // 佐藤

// 部署ごとに年齢の平均を算出
Map<String, Double> averageAgeByDepartment = Arrays.stream(people)  
  .collect(Collectors.groupingBy(
    Person::getDepartment,
    Collectors.averagingInt(Person::getAge)
  ));
IO.println(averageAgeByDepartment);       // {営業=25.0, 開発=37.0, 総務=30.0}

// 部署ごとに最年長者を取得
Map<String, Optional<Person>> oldestByDepartment = Arrays.stream(people)
  .collect(Collectors.groupingBy(
    Person::getDepartment,
    Collectors.maxBy(Comparator.comparingInt(Person::getAge))
  ));
IO.println(oldestByDepartment.get("開発").get().getName());  // 田中

Person[] people = {
  new Person("佐藤", 28, "営業"),
  new Person("鈴木", 34, "開発"),
  new Person("高橋", 22, "営業"),
  new Person("田中", 40, "開発"),
  new Person("伊藤", 30, "総務")
};

// 部署ごとに名前のリストを取得
Map<String, List<String>> namesByDepartment = Arrays.stream(people)
  .collect(Collectors.groupingBy(
    Person::getDepartment,
    Collectors.mapping(Person::getName, Collectors.toList())
  ));
IO.println(namesByDepartment);  // {営業=[佐藤, 高橋], 開発=[鈴木, 田中], 総務=[伊藤]}

// 部署ごとに名前をカンマ区切りでグルーピング
Map<String, String> namesJoinedByDepartment = Arrays.stream(people) 
  .collect(Collectors.groupingBy(
    Person::getDepartment,
    Collectors.collectingAndThen(
      Collectors.mapping(Person::getName, Collectors.toList()),
      names -> String.join(", ", names)
    )
  ));
IO.println(namesJoinedByDepartment);  // {営業=佐藤, 高橋, 開発=鈴木, 田中, 総務=伊藤}

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> filteredNames = new ArrayList<>();
for (String name : names) {
  if (name.contains("藤")) {
    filteredNames.add(name);
  }
}
IO.println(filteredNames);    // [佐藤, 伊藤]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> filteredNames = names.stream()
  .filter(name -> name.contains("藤"))
  .collect(Collectors.toList());
IO.println(filteredNames);    // [佐藤, 伊藤]

// Listの場合
List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
Stream<String> nameStream = names.stream();

// Setの場合
Set<String> nameSet = Set.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
Stream<String> nameStreamFromSet = nameSet.stream();

// Mapの場合
Map<String, Integer> nameAgeMap = Map.ofEntries(
  Map.entry("佐藤", 30),
  Map.entry("鈴木", 25),
  Map.entry("高橋", 28),
  Map.entry("田中", 22),
  Map.entry("伊藤", 35)
);
Stream<Map.Entry<String, Integer>> nameAgeStream = nameAgeMap.entrySet().stream();

// 配列の場合
String[] nameArray = {"佐藤", "鈴木", "高橋", "田中", "伊藤"};
Stream<String> nameStreamFromArray = Arrays.stream(nameArray);

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> filteredNames = names.stream()
  .filter(name -> name.contains("藤"))
  .collect(Collectors.toList());
IO.println(filteredNames);    // [佐藤, 伊藤]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> uppercasedNames = names.stream()
  .map(name -> name + "さん")
  .collect(Collectors.toList());
IO.println(uppercasedNames);    // [佐藤さん, 鈴木さん, 高橋さん, 田中さん, 伊藤さん]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤", "佐藤", "伊藤");
List<String> distinctNames = names.stream()
  .distinct()
  .collect(Collectors.toList());
IO.println(distinctNames);    // [佐藤, 鈴木, 高橋, 田中, 伊藤]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> sortedNames = names.stream()
  .sorted()
  .collect(Collectors.toList());
IO.println(sortedNames);    // [伊藤, 佐藤, 鈴木, 高橋, 田中]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
names.stream().forEach(name -> IO.println(name));
// 佐藤
// 鈴木
// 高橋
// 田中
// 伊藤

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> filteredNames = names.stream()
  .filter(name -> name.contains("藤"))
  .collect(Collectors.toList());
IO.println(filteredNames);    // [佐藤, 伊藤]

List<String> names02 = List.of("佐藤", "鈴木一", "高橋", "田中恵", "伊藤", "山", "小林", "山田太郎");
Map<Integer, List<String>> groupedByLength = names02.stream()
  .collect(Collectors.groupingBy(String::length));
IO.println(groupedByLength);    // {1=[山], 2=[佐藤, 高橋, 伊藤, 小林], 3=[鈴木一, 田中恵], 4=[山田太郎]}

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
long count = names.stream()
  .filter(name -> name.contains("藤"))
  .count();
IO.println(count);    // 2

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int sum = numbers.stream()
  .reduce(0, Integer::sum);
IO.println(sum);    // 15

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int sum2 = numbers.stream()
  .mapToInt(Integer::intValue)
  .sum();
IO.println(sum2);    // 15

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");

// anyMatch
boolean hasSuzuki = names.stream()
  .anyMatch(name -> name.equals("鈴木"));
IO.println(hasSuzuki);    // true

// allMatch
boolean allHaveTo = names.stream()
  .allMatch(name -> name.contains("田"));
IO.println(allHaveTo);    // false

// noneMatch
boolean noneHaveYamamoto = names.stream()
  .noneMatch(name -> name.equals("山本"));
IO.println(noneHaveYamamoto);    // true

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");

names.parallelStream()
.filter(name -> {
  IO.println("フィルタ中: " + name + " - " + Thread.currentThread().getName());
  return name.contains("藤");
})
.map(name -> {
  IO.println("変換中: " + name + " - " + Thread.currentThread().getName());
  return "こんにちは、" + name + "さん";
})
.forEach(name -> IO.println(name));

フィルタ中: 伊藤 - ForkJoinPool.commonPool-worker-3
フィルタ中: 佐藤 - ForkJoinPool.commonPool-worker-2
フィルタ中: 田中 - ForkJoinPool.commonPool-worker-4
変換中: 伊藤 - ForkJoinPool.commonPool-worker-3
変換中: 佐藤 - ForkJoinPool.commonPool-worker-2
フィルタ中: 高橋 - main
フィルタ中: 鈴木 - ForkJoinPool.commonPool-worker-1
こんにちは、佐藤さん
こんにちは、伊藤さん

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter'
}

@Component
public class HelloRunner implements ApplicationRunner {

  @Override
  public void run(ApplicationArguments args) throws Exception {
    System.out.println("Hello World!");
  }
}

./gradlew bootRun

Hello World!

@Component
@ConditionalOnProperty(value = {"batch.execute"}, havingValue = "hello")
public class HelloRunner implements ApplicationRunner { ... }

./gradlew bootRun --args="--batch.execute=hello"

Hello World!

  @Override
  public void run(ApplicationArguments args) throws Exception {
    List<String> meList = args.getOptionValues("me");
    String me = (meList != null && !meList.isEmpty() ? meList.get(0) : "everyone");
    System.out.println("Hello " + me  + "!");
  }

./gradlew bootRun --args="--batch.execute=hello --me=n-ozawan"

Hello n-ozawan!

@SpringBootApplication
public class Application {

  public static void main(String[] args) {
    ApplicationContext ctx = SpringApplication.run(Application.class, args);
    System.exit(SpringApplication.exit(ctx));
  }
}

@Component
@ConditionalOnProperty(value = {"batch.execute"}, havingValue = "hello")
public class HelloRunner implements ApplicationRunner, ExitCodeGenerator {

  private int exitCode;

  @Override
  public int getExitCode() {
    return exitCode;
  }

  @Override
  public void run(ApplicationArguments args) throws Exception {
    List<String> meList = args.getOptionValues("me");
    String me = !meList.isEmpty() ? meList.get(0) : "everyone";
    if (me.equals("n-ozawan")) {
      exitCode = 1;
      return ;
    } 
    System.out.println("Hello " + me + "!");
  }
}

./gradlew bootRun --args="--batch.execute=hello --me=n-ozawan"

Execution failed for task ':bootRun'.
> Process 'command '/home/n-ozawan/.sdkman/candidates/java/17.0.8-tem/bin/java'' finished with non-zero exit value 1

echo $?

1

@Component
@ConditionalOnProperty(value = {"batch.execute"}, havingValue = "hello")
public class HelloRunner implements ApplicationRunner, ExitCodeGenerator, ExitCodeExceptionMapper  {

  // (省略)

  @Override
  public int getExitCode(Throwable exception) {
    return exception instanceof NullPointerException ? 9 : 1;
  }

  // (省略)
}

./gradlew bootRun --args="--batch.execute=hello"

Execution failed for task ':bootRun'.
> Process 'command '/home/n-ozawan/.sdkman/candidates/java/17.0.8-tem/bin/java'' finished with non-zero exit value 9

echo $?

1

./gradlew build
java -jar ./build/libs/spring-boot-0.0.1-SNAPSHOT.jar --batch.execute=hello
echo $?

9

chmod +x gradlew

./gradlew bootRun

curl http://localhost:8080

Greetings from Spring Boot!

./gradlew bootBuildImage --imageName=spring-boot-app

FROM openjdk:21-jdk
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

./gradlew build && docker build --build-arg JAR_FILE=build/libs/spring-boot-0.0.1-SNAPSHOT.jar -t spring-boot-app .

docker run -p 8080:8080 -it spring-boot-app

curl http://localhost:8080

Greetings from Spring Boot!

spotless {
  typescript {
    target 'src/**/*.ts'
    prettier().configFile 'path-to/.prettierrc.yml'
  }
}

plugins {
	id 'com.diffplug.spotless' version '6.25.0'
}

spotless {
  java {
    eclipse().configFile project.file("config/formatter/eclipse-java-style.xml")
  }
}

spotless {
  java {
    googleJavaFormat()
  }
}

./gradlew check

./gradlew spotlessJavaCheck

./gradlew spotlessApply

{
  "editor.formatOnSave": true,
  "editor.formatOnPaste": true,
  "java.format.settings.url": "config/formatter/eclipse-java-style.xml"
}

plugins {
    id 'checkstyle'
}

checkstyle {
    toolVersion = "10.12.4"
}

checkstyle {
    toolVersion = "10.12.4"
    configFile = file("${rootProject.projectDir}/google_checks.xml")
}

./gradlew check

./gradlew checkstyleMain checkstyleTest

spring.security.oauth2.client.registration.keycloak.client-id=client.java
spring.security.oauth2.client.registration.keycloak.client-secret=ZqvbEgW55uqlNoO9zABpGSGGvkpQmRlP
spring.security.oauth2.client.registration.keycloak.provider=keycloak
spring.security.oauth2.client.registration.keycloak.scope=openid
spring.security.oauth2.client.registration.keycloak.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.keycloak.redirect-uri={baseUrl}/login/oauth2/code/{registrationId}

spring.security.oauth2.client.provider.keycloak.issuer-uri: http://localhost:8080/realms/myrealm
spring.security.oauth2.client.provider.keycloak.authorization-uri=http://localhost:8080/realms/myrealm/protocol/openid-connect/auth
spring.security.oauth2.client.provider.keycloak.token-uri=http://localhost:8080/realms/myrealm/protocol/openid-connect/token
spring.security.oauth2.client.provider.keycloak.user-info-uri=http://localhost:8080/realms/myrealm/protocol/openid-connect/userinfo
spring.security.oauth2.client.provider.keycloak.jwk-set-uri=http://localhost:8080/realms/myrealm/protocol/openid-connect/certs
spring.security.oauth2.client.provider.keycloak.user-name-attribute=preferred_username

@Configuration
@EnableWebSecurity
public class SecurityConfig {

  @Bean
  public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
      .authorizeHttpRequests(authorize -> authorize.anyRequest().authenticated())
      .oauth2Login(Customizer.withDefaults());

    return http.build();
  }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {

  @Bean
  public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
      .authorizeHttpRequests(authorize -> authorize.anyRequest().authenticated())
      .oauth2Login(oauth2 -> 
        oauth2.redirectionEndpoint(redirection -> redirection.baseUri("/my_redirect"))
      );

    return http.build();
  }
}

DefaultOidcUser oidcUser = (DefaultOidcUser) SecurityContextHolder
  .getContext()
  .getAuthentication()
  .getPrincipal();

// ログインしたユーザーの名前を取得
model.addAttribute("displayName", oidcUser.getFullName());

@Service
public class OAuth2TokenService {

  @Autowired
  private OAuth2AuthorizedClientService clientService;

  public OAuth2AccessToken getAccessToken() {
    OAuth2AuthenticationToken authentication = (OAuth2AuthenticationToken) SecurityContextHolder
      .getContext()
      .getAuthentication();

    OAuth2AuthorizedClient authorizedClient = clientService.loadAuthorizedClient(
      authentication.getAuthorizedClientRegistrationId(),
      authentication.getName()
    );

    return authorizedClient.getAccessToken();
  }
}

$ cd
$ tar -zxvf /mnt/c/Users/xxx/Downloads/eclipse-java-2023-06-R-linux-gtk-x86_64.tar.gz

$ cd ~/eclipse
$ ./eclipse

# WSL
$ cd ~/workspace/example_project
$ code .

[wsl2]
memory=1GB

$ curl -s "https://get.sdkman.io" | bash

$ sdk version

$ sdk install java                 # (2023-07-25時点) TemurinのLTS(17.0.8) をインストールする
$ sdk install java 17.0.8-oracle   # Oracle Java JDK 17.0.8 をインストールする

$ sdk uninstall java 17.0.8-oracle

$ sdk current           # 使用中のすべてのツールキットのバージョンを確認する
$ sdk current java      # 使用中の Java JDK を確認する

$ sdk use java 17.0.8-oracle

$ sdk default java 17.0.8-oracle

$ sdk list java

$ sdk env init         # .sdkmanrc を作成する
$ sdk env install      # .sdkmanrc に記述されているツールキットをすべてインストールする
$ sdk env              # .sdkmanrc に記述されているツールキットに切り替える