Java コード スニペット:)

構文

アクセス修飾子:

公開
public として定義されたクラス、メソッド、または変数には、任意のクラスまたはメソッドからアクセスできます。

保護されています
Protected には、同じパッケージのクラス、このクラスのサブクラス、または同じクラス内からアクセスできます。
(注: このキーワードはネストされたクラスでのみ使用できます)

プライベート
プライベートとして定義されたプライベート クラス、メソッド、または変数には、クラス内でのみアクセスできます。

デフォルト
デフォルトはパッケージ内でのみアクセス可能です。デフォルトでは、すべてのクラス、メソッド、変数がデフォルトのスコープになります。

package com.example;

public class Example {
    private int privateVar = 10;
    int defaultVar = 20;
    protected int protectedVar = 30;
    public int publicVar = 40;

    public static void main(String[] args) {
        Example example = new Example();

        // Accessing all variables within the same class
        System.out.println("Private Var: " + example.privateVar);
        System.out.println("Default Var: " + example.defaultVar);
        System.out.println("Protected Var: " + example.protectedVar);
        System.out.println("Public Var: " + example.publicVar);
    }
}

//Another file
package com.example;

public class Example1 {
    public static void main(String[] args) {
        Example example = new Example();

        // Private variable is inaccessible
        System.out.println("Default Var: " + example.defaultVar);
        System.out.println("Protected Var: " + example.protectedVar);
        System.out.println("Public Var: " + example.publicVar);
    }
}

// File: Different.java
package com.example.subpackage;

import com.example.Example;

public class Different extends Example {
    public static void main(String[] args) {
        Example example = new Example();
        Different subClassExample = new Different();

        // Private variable is inaccessible
        // Default variable is inaccessible
        // Protected variable is inaccessible
        System.out.println("Public Var: " + example.publicVar);

        // Accessing protected variable through inheritance
        System.out.println("Protected Var (through inheritance): " + subClassExample.protectedVar);
    }
}

データ型

public class Main {

    // Class to demonstrate structure equivalent
    static class Person {
        String name; // Default value is null
        int age; // Default value is 0
        float salary; // Default value is 0.0f
    }

    // Enumeration to demonstrate enum equivalent
    enum Color { RED, GREEN, BLUE }

    public static void main(String[] args) {

        // Basic data types
        int a = 10; // Default value is 0
        float b = 5.5f; // Default value is 0.0f
        char c = 'A'; // Default value is '\u0000'
        double d = 2.3; // Default value is 0.0d
        long e = 123456789L; // Default value is 0L
        short f = 32000; // Default value is 0
        byte g = 100; // Default value is 0

        // Array
        int[] arr = {1, 2, 3, 4, 5};

        // Structure equivalent
        Person person1 = new Person();
        person1.age = 30;
        person1.salary = 55000.50f;

        // Enumeration
        Color myColor = Color.RED;
    }
}

過負荷

メソッドのオーバーロードは、複数のメソッドが同じ名前を持つが、同じクラス内で異なるパラメーターを持つ場合に発生します。これはコンパイル時に解決されます。

class MathOperations {
    // Method to add two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Method to add three integers
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // Method to add two double values
    public double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        MathOperations math = new MathOperations();

        System.out.println(math.add(2, 3));
        System.out.println(math.add(1, 2, 3));
        System.out.println(math.add(2.5, 3.5));
    }
}

オーバーライド

メソッドのオーバーライドは、サブクラスが、そのスーパークラスですでに定義されているメソッドの特定の実装を提供するときに発生します。これは実行時に解決されます

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.makeSound(); // Calls method in Animal class

        Dog myDog = new Dog();
        myDog.makeSound(); // Calls overridden method in Dog class
    }
}

配列

配列とオブジェクトは、コピーではなく、常に参照によって渡されます。プリミティブ データ型は値によって渡されます。

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

        // Integer array
        int[] intArray = new int[5]; // Default values: 0
        int[] intArray2 = {1, 2, 3, 4, 5}; // Initialized with specific values

        // Float array
        float[] floatArray = new float[5]; // Default values: 0.0f
        float[] floatArray2 = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f}; // Initialized with specific values

    }
}

デフォルトのキーワード

デフォルト メソッドは、default キーワードを使用してインターフェイスで定義されたメソッドです。これにより、インターフェースを実装するクラスに影響を与えることなく、インターフェースがメソッド実装を提供できるようになります。

interface Animal {
    void makeSound(); // abstract method

    // Default method
    default void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();

        dog.makeSound(); // Output: Bark
        dog.sleep();     // Output: Sleeping...

    }
}

静的キーワード

メンバー (変数、メソッド、またはネストされたクラス) が、クラスのインスタンスではなくクラス自体に属していることを示します。
(注: 非静的メソッド内で静的変数を宣言することはできません)

public class StaticExample {
    // Static variable
    static int staticVariable = 10;

    // Instance variable
    int instanceVariable = 20;

    // Static method
    static void staticMethod() {
        // Can access static variable
        System.out.println(staticVariable);

        // Cannot access instance variable directly
        // System.out.println(instanceVariable);
    }

    // Instance method
    void instanceMethod() {

        // Can access static variable
        System.out.println(staticVariable);

        // Can access instance variable
        System.out.println(instanceVariable);
    }

    // Static nested class
    static class StaticNestedClass {
        void display() {
            System.out.println("Static nested class method called.");
            // Can access static members of the outer class
            System.out.println("Static variable from nested class: " + staticVariable);
        }
    }

    public static void main(String[] args) {
        // Call static method
        StaticExample.staticMethod();

        // Create an instance of the class
        StaticExample example = new StaticExample();
        // Call instance method
        example.instanceMethod();

        // Create an instance of the static nested class
        StaticNestedClass nestedClass = new StaticNestedClass();
        nestedClass.display();
    }
}

初期化

(注: インスタンス変数と静的変数のみがデフォルト値で初期化されます)

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
          int num;
          int num1=0;
          System.out.println(num); //Throws error
          System.out.println(num1); // prints 0 
    }
}

クラスのメソッドとそのパラメータを表示します

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = LinkedList.class;
        // Get all methods of the class
        Method[] methods = clazz.getDeclaredMethods();
        // Print the names and parameters of all methods
        for (Method method : methods) {
            System.out.print("Method Name: " + method.getName());
            System.out.print(", Parameters: ");
            Parameter[] parameters = method.getParameters();
            for (Parameter parameter : parameters) {
                System.out.print(parameter.getType().getName() + " " + parameter.getName() + ", ");
            }
            System.out.println();
        }
    }
}

基本的な入出力

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        // Reading integer input
        System.out.print("Enter an integer: ");
        int intValue = scan.nextInt();
        System.out.println("Integer entered: " + intValue);

        // Reading double input
        System.out.print("Enter a double: ");
        double doubleValue = scan.nextDouble();
        System.out.println("Double entered: " + doubleValue);

        // Reading string input (including spaces)
        System.out.print("Enter a string: ");
        scan.nextLine(); // Consume the newline character
        String stringValue = scan.nextLine();
        System.out.println("String entered: " + stringValue);

        // Reading character input
        System.out.print("Enter a character: ");
        char charValue = scan.next().charAt(0);
        System.out.println("Character entered: " + charValue);

        // Reading boolean input
        System.out.print("Enter a boolean (true/false): ");
        boolean booleanValue = scan.nextBoolean();
        System.out.println("Boolean entered: " + booleanValue);

        // Reading input until there is no more input available
        System.out.println("Enter multiple lines of input (Ctrl+D / Ctrl+Z to exit):");
        scan.nextLine(); // Consume the newline character
        while (scan.hasNext()) {
            String line = scan.nextLine();
            System.out.println("Input: " + line);
        }

        scan.close();
    }
}

For ループ

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; ++i) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

While ループ

public class Main {
    public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            System.out.print(i + " ");
            ++i;
        }
        System.out.println();
    }
}

機能

public class Main {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(5, 3);
        System.out.println("Sum: " + result);
    }
}

クラスとオブジェクト

public class Rectangle {
    private int width, height;

    public Rectangle(int w, int h) {
        this.width = w;
        this.height = h;
    }

    public int area() {
        return width * height;
    }

    public static void main(String[] args) {
        Rectangle rect = new Rectangle(5, 3);
        System.out.println("Area: " + rect.area());
    }
}

継承

public class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }

    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw();
    }
}

最後のキーワード

final キーワードを追加して作成されます

1) 最終変数
この変数は一度初期化されると変更できません

public class FinalVariableExample {
    public static void main(String[] args) {
        final int x = 10;
        // x = 20; // This will cause a compilation error
        System.out.println(x);// 10
    }
}

2) 最終的な方法
これらのメソッドはオーバーライドできません

class Parent {
    final void show() {
        System.out.println("This is a final method.");
    }
}

class Child extends Parent {
    // void show() { // This will cause a compilation error
    //    System.out.println("Trying to override.");
    // }
}

public class FinalMethodExample {
    public static void main(String[] args) {
        Child c = new Child();
        c.show(); // Output: This is a final method.
    }
}

スーパーキーワード

Java の super キーワードは、現在のオブジェクトの直接の親クラスを参照するために使用されます。これは、子クラス内から親クラスのメンバー (メソッドと変数) にアクセスする方法を提供します。

class Parent {
    int x = 10;

    void display() {
        System.out.println("Parent's display method");
    }

    Parent() {
        System.out.println("Parent's constructor");
    }
}

class Child extends Parent {
    int x = 20;

    void display() {
        super.display(); // Calls the display method of Parent class
        System.out.println("Child's display method");
    }

    Child() {
        super(); // Calls the constructor of Parent class
        System.out.println("Child's constructor");
    }
}

public class Test {
    public static void main(String[] args) {
        Child obj = new Child();
        System.out.println("Value of x in Child: " + obj.x);
        obj.display();
    }
}

抽象的な

Java の abstract キーワードは、抽象クラスと抽象メソッドを定義するために使用されます。抽象クラスは直接インスタンス化することができず、サブクラス化することを意図しています。抽象メソッドには本体がないため、サブクラスによって実装する必要があります。
抽象メソッドと具象メソッドが含まれています

abstract class Animal {
    // Abstract method (does not have a body)
    abstract void makeSound();

    // Regular method
    void eat() {
        System.out.println("This animal is eating.");
    }
}

class Dog extends Animal {
    // The body of the abstract method is provided here
    void makeSound() {
        System.out.println("Woof");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.makeSound();  // Output: Woof
        myDog.eat();        // Output: This animal is eating.
    }
}

あるインターフェースが別のインターフェースからメソッドを継承したい場合、extends キーワードを使用します。

抽象クラスはインターフェースを実装できます。これは、抽象クラスが、implements キーワードを使用してインターフェイスの部分的な実装を提供することを意味します。

抽象クラスは extends キーワードを使用して別の抽象クラスを拡張できます

インタフェース

定数、デフォルトメソッド、静的メソッド、メソッドシグネチャのみを含むクラスに似た参照型です
(注: インターフェイスにはデフォルトのメソッドの定義のみが存在します)
(注: インターフェース内で宣言された定数は public、static、および final です)

interface Animal {
    void makeSound(); // abstract method
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }
}

class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound(); // Output: Bark
        cat.makeSound(); // Output: Meow
    }
}

ダイアモンド問題の克服 (多重継承):

interface A {
    void display();
}

interface B extends A {
    default void display() {
        System.out.println("Display from B");
    }
}

interface C extends A {
    default void display() {
        System.out.println("Display from C");
    }
}

class D implements B, C {

    @Override
    public void display() {
        B.super.display();
        C.super.display();
        System.out.println("Display from D");
    }
}

public class Main {
    public static void main(String[] args) {
        D d = new D();
        d.display();

        //Output
        //Display from B
        //Display from C
        //Display from D
    }
}

リスト

import java.util.LinkedList;
import java.util.List;
import java.util.ArrayList;

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

        // Declare list as LinkedList
        List<Character> list = new LinkedList<>();

        // Add elements
        list.add('A');
        list.add('B');
        list.add('C');

        // Change implementation to ArrayList
        list = new ArrayList<>(list);

        // Add more elements
        list.add('D');
        list.add('E');

        // Change implementation to Vector
        list = new Vector<>(list);

        // Add more elements
        list.add('F');
        list.add('G');
    }
}

列

Java の Queue インターフェイスは Java Collections Framework の一部であり、処理前の要素を保持するために設計されたコレクションを表します。通常、要素は FIFO (先入れ先出し) 方式で順序付けされますが、Deque 実装の場合の LIFO (後入れ先出し) など、他の順序付けも可能です。

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Deque;

public class QueueExample {
    public static void main(String[] args) {
        // Using LinkedList as a Queue
        Queue<String> queue = new LinkedList<>();
        queue.add("Java");
        queue.add("Python");
        queue.add("C++");

        // Reassigning to PriorityQueue
        queue = new PriorityQueue<>();
        queue.add("Java");
        queue.add("Python");
        queue.add("C++");

        // Reassigning to ArrayDeque
        queue = new ArrayDeque<>();
        queue.add("Java");
        queue.add("Python");
        queue.add("C++");
    }
}

コレクション

配列リスト

1.動的サイズ変更
2.リストインターフェイスを実装します

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        for (int num : list) {
            System.out.print(num + " ");
        }
        System.out.println();

        // Inserting an element
        list.add(2, "Ruby");

        // Accessing elements
        System.out.println("Element at index 3: + list.get(3));

        // Removing an element 
        list.remove(1);

        // Size of the list 
        System.out.println(list.size());

        // Check if list is empty 
        System.out.println("Is list empty? + list.isEmpty());

        // Check if list contains an element 
        System.out.println(list.contains("Java"));

        // Index of an element 
        System.out.println(list.indexOf("JavaScript"));

        // Last index of an element 
        System.out.println(list.lastIndexOf("Ruby"));

        // Clear the list
        list.clear()
    }
}

Stack

import java.util.Stack;

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

        // Create a stack
        Stack<String> stack = new Stack<>();

        // Push elements onto the stack
        stack.push("Java");
        stack.push("Python");
        stack.push("C++");

        // Print the stack after pushes
        System.out.println("Stack after pushes: " + stack);

        // Get the size of the stack
        int size = stack.size();
        System.out.println("Size of stack: " + size);

        // Peek at the top element without removing it
        String topElement = stack.peek();
        System.out.println("Top element (peek): " + topElement);

        // Pop an element from the stack
        String poppedElement = stack.pop();
        System.out.println("Popped element: " + poppedElement);

        // Print the stack after pop
        System.out.println("Stack after pop: " + stack);

        // Check if the stack is empty
        boolean isEmpty = stack.isEmpty();
        System.out.println("Is stack empty? " + isEmpty);

        // Get the size of the stack after pop
        size = stack.size();
        System.out.println("Size of stack after pop: " + size);

        // Search for an element
        int position = stack.search("Java");
        System.out.println("Position of element 'Java': " + position);
    }
}

LinkedList

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // Create a new LinkedList
        LinkedList<String> linkedList = new LinkedList<>();

        // Add elements to the LinkedList
        linkedList.add("Java");
        linkedList.add("Python");
        linkedList.add("C++");
        System.out.println("Initial LinkedList: " + linkedList);

        // Add element at specific index
        linkedList.add(1, "JavaScript");
        System.out.println("After add(1, 'JavaScript'): " + linkedList);

        // Add element at the beginning
        linkedList.addFirst("HTML");
        System.out.println("After addFirst('HTML'): " + linkedList);

        // Add element at the end
        linkedList.addLast("CSS");
        System.out.println("After addLast('CSS'): " + linkedList);

        // Get elements
        System.out.println("First element: " + linkedList.getFirst());
        System.out.println("Last element: " + linkedList.getLast());
        System.out.println("Element at index 2: " + linkedList.get(2));

        // Remove elements
        linkedList.remove(); // removes the first element
        System.out.println("After remove(): " + linkedList);

        linkedList.remove(2); // removes the element at index 2
        System.out.println("After remove(2): " + linkedList);

        linkedList.removeFirst(); // removes the first element
        System.out.println("After removeFirst(): " + linkedList);

        linkedList.removeLast(); // removes the last element
        System.out.println("After removeLast(): " + linkedList);

        // Check if the list contains a specific element
        System.out.println("Contains 'Python': " + linkedList.contains("Python"));

        // Get the size of the list
        System.out.println("Size of LinkedList: " + linkedList.size());

        // Clear the list
        linkedList.clear();
        System.out.println("After clear(): " + linkedList);

        // Check if the list is empty
        System.out.println("Is LinkedList empty? " + linkedList.isEmpty());
    }
}

HashMap

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Alice", 90);
        map.put("Bob", 85);

        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
    }
}

String

public class StringExamples {
    public static void main(String[] args) {
        // Creating an empty string
        String emptyString = new String();
        System.out.println("Empty String: \"" + emptyString + "\"");

        // Creating a string from another string
        String original = "Hello, World!";
        String copy = new String(original);
        System.out.println("Copy of original: " + copy);

        // Creating a string from a character array
        char[] charArray = {'J', 'a', 'v', 'a'};
        String fromCharArray = new String(charArray);
        System.out.println("String from char array: " + fromCharArray);

        // Length of the string
        int length = original.length();
        System.out.println("Length of original string: " + length);

        //Check if two strings are equal
        String str1 = "Java";
        String str2 = "Java";

        System.out.println(str1.equals(str2)); // true


        // Check if the string is empty
        boolean isEmpty = original.isEmpty();
        System.out.println("Is original string empty? " + isEmpty);

        // Character at a specific index
        char charAt2 = original.charAt(2);
        System.out.println("Character at index 2 in original string: " + charAt2);

        // Convert to uppercase
        String upperCaseStr = original.toUpperCase();
        System.out.println("Uppercase: " + upperCaseStr);

        // Convert to lowercase
        String lowerCaseStr = original.toLowerCase();
        System.out.println("Lowercase: " + lowerCaseStr);

        // Character methods
        char ch1 = 'A';
        char ch2 = 'a';
        char ch3 = '1';
        char ch4 = ' ';
        char ch5 = '\u2603'; // Unicode character for snowman

        System.out.println("isDigit('1'): " + Character.isDigit(ch3)); // true
        System.out.println("isLetter('A'): " + Character.isLetter(ch1)); // true
        System.out.println("isLetterOrDigit('a'): " + Character.isLetterOrDigit(ch2)); // true
        System.out.println("isLowerCase('a'): " + Character.isLowerCase(ch2)); // true
        System.out.println("isUpperCase('A'): " + Character.isUpperCase(ch1)); // true
        System.out.println("isWhitespace(' '): " + Character.isWhitespace(ch4)); // true
        System.out.println("toLowerCase('A'): " + Character.toLowerCase(ch1)); // 'a'
        System.out.println("toUpperCase('a'): " + Character.toUpperCase(ch2)); // 'A'

        // Reverse a string using StringBuilder
        String reversedStr = reverseUsingStringBuilder(original);
        System.out.println("Reversed string: " + reversedStr);
    }

    public static String reverseUsingStringBuilder(String str) {
        StringBuilder stringBuilder = new StringBuilder(str);
        stringBuilder.reverse();
        return stringBuilder.toString();
    }
}

File I/O

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

public class Main {
    public static void main(String[] args) {
        // Write to file
        try (FileWriter writer = new FileWriter("example.txt")) {
            writer.write("Hello, file I/O!\n");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Read from file
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Exception Handling

(Note: When catching exceptions the more specific exceptions must be listed before the more general)

public class Main {
    public static int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero");
        }
        return a / b;
    }

    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Inner Classes

An inner class is a class defined within another class.

1. Member Inner Class A member inner class is associated with an instance of the outer class. It has access to the outer class's instance variables and methods.

public class OuterClass {
    private String outerField = "Outer Field";

    class InnerClass {
        void display() {
            System.out.println("Accessing outer field: " + outerField);
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
    }
}

1. Static Nested Class A static nested class is a static class defined within another class. It does not have access to the instance members of the outer class but can access its static members.

public class OuterClass {
    private static String staticField = "Static Field";

    static class StaticNestedClass {
        void display() {
            System.out.println("Accessing static field: " + staticField);
        }
    }

    public static void main(String[] args) {
        OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
        nested.display();
    }
}

1. Local Inner Class A local inner class is defined within a block or method and can access local variables (which must be final or effectively final) and the outer class's members.

public class OuterClass {
    void method() {
        final String localVariable = "Local Variable";

        class LocalInnerClass {
            void display() {
                System.out.println("Accessing local variable: " + localVariable);
            }
        }

        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.method();
    }
}

1. Anonymous Inner Class An anonymous inner class is a type of inner class without a name. It can extend exactly one class or implement exactly one interface

class BaseClass {
    void display() {
        System.out.println("BaseClass display()");
    }
}

public class Main {
    public static void main(String[] args) {
        BaseClass obj = new BaseClass() {
            @Override
            void display() {
                System.out.println("Anonymous inner class display()");
            }
        };

        obj.display();
    }
}

Lambda Expressions

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);
        nums.add(5);

        nums.replaceAll(n -> n * 2);

        for (int num : nums) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

Switch Statement

public class Main {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Invalid day");
                break;
        }
    }
}

Normal Pointers

Java does not use explicit pointers as C++ does;

Lower and Upper case:

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello, World!";
        String str2= "HELLO, WORLD!";

        String lowerStr = str2.toLowerCase();
        String upperStr = str1.toUpperCase();

        System.out.println(lowerStr);  // Output: hello, world!
        System.out.println(upperStr);  // Output: HELLO, WORLD!
    }
}

以上がJava コード スニペット:)の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。