java 入门教程(非常详细!1.6w+ 文字)

先序: 学习编程语言要先学个轮廓,刚开始只用学核心的部分,一些细节、不常用的内容先放着,现用现查即可;把常用的东西弄熟练了在慢慢补充。

1. Java 概述

Java 是一种面向对象的编程语言,由 Sun Microsystems(现在的 Oracle)在 1995 年推出。Java 程序可以在任何支持 Java 虚拟机 (JVM) 的设备上运行。Java 的核心理念是“一次编写,到处运行”。

2. 基本语法

2.1 Java 程序结构

每个 Java 程序都由类 (class) 和方法 (method) 组成。以下是一个简单的 Java 程序示例:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
  • public class HelloWorld:定义一个名为 HelloWorld 的公共类。
  • public static void main(String[] args):主方法,是程序的入口点。
  • System.out.println("Hello, World!");:打印一行文本到控制台。

2.2 注释

Java 支持三种类型的注释:

  • 单行注释:使用 //
  • 多行注释:使用 /* ... */
  • 文档注释:使用 /** ... */

3. 数据类型

Java 的数据类型分为两大类:基本数据类型 (primitive types) 和引用数据类型 (reference types)。

3.1 基本数据类型

  • 整型byte, short, int, long
  • 浮点型float, double
  • 字符型char
  • 布尔型boolean
int number = 10;
float pi = 3.14f;
char letter = 'A';
boolean isJavaFun = true;

3.2 引用数据类型

引用数据类型包括类 (class), 接口 (interface), 数组 (array),以及枚举 (enum)。

4. 运算符

Java 提供了丰富的运算符,包括:

  • 算术运算符+, -, *, /, %
  • 赋值运算符=, +=, -=, *=, /=, %=
  • 比较运算符==, !=, >, <, >=, <=
  • 逻辑运算符&&, ||, !
  • 位运算符&, |, ^, ~, <<, >>, >>>
int a = 5;
int b = 10;
int sum = a + b; // 加法
boolean isEqual = (a == b); // 比较

5. 判断和循环

5.1 条件语句

  • if 语句:用于条件判断
  • switch 语句:用于多分支选择
if (a > b) {
    System.out.println("a is greater than b");
} else if (a < b) {
    System.out.println("a is less than b");
} else {
    System.out.println("a is equal to b");
}

switch (a) {
    case 1:
        System.out.println("a is 1");
        break;
    case 2:
        System.out.println("a is 2");
        break;
    default:
        System.out.println("a is not 1 or 2");
}

5.2 循环语句

  • for 循环:用于固定次数的循环
  • while 循环:用于条件控制的循环
  • do-while 循环:至少执行一次的循环
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

int j = 0;
while (j < 5) {
    System.out.println(j);
    j++;
}

int k = 0;
do {
    System.out.println(k);
    k++;
} while (k < 5);

5.3 常用遍历方法

在 Java 中,遍历数组和字符串是常见的操作。下面详细介绍几种常用的遍历方法。

1. 遍历数组的方法

1.1 使用 for 循环

传统的 for 循环是遍历数组的常见方法:

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

这里的 i 是数组的索引,通过 numbers[i] 获取数组元素。

1.2 使用增强型 for 循环(for-each 循环)

增强型 for 循环简化了数组的遍历,不需要使用索引:

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
    System.out.println(number);
}

这种方法直接获取数组中的每个元素,语法简洁。

2. 遍历字符串的方法

2.1 使用 for 循环

字符串可以看作是字符数组,可以用 for 循环逐个字符地遍历:

String text = "Hello";
for (int i = 0; i < text.length(); i++) {
    System.out.println(text.charAt(i));
}

charAt(i) 方法返回字符串中第 i 个字符。

2.2 使用增强型 for 循环(for-each 循环)

虽然增强型 for 循环不能直接用于 String,但可以将字符串转换为字符数组后进行遍历:

String text = "Hello";
for (char ch : text.toCharArray()) {
    System.out.println(ch);
}

toCharArray() 方法将字符串转换为字符数组,然后进行遍历。

2.3 使用 Stream API

同样地,可以使用 Stream API 来遍历字符串:

String text = "Hello";
text.chars().forEach(c -> System.out.println((char) c));

chars() 方法返回一个包含字符的 IntStream,需要将 int 类型转换为 char 类型。

3. 其他的遍历方法

3.1 使用迭代器(Iterator

对于集合类(如 ListSet 等),可以使用 Iterator 进行遍历:

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

Iterator 提供了 hasNext()next() 方法,用于顺序访问集合中的元素。

3.2 使用 forEach 方法

Java 8 引入的 forEach 方法可以直接用于遍历集合和 Map

List<String> list = Arrays.asList("A", "B", "C");
list.forEach(System.out::println);

Map<Integer, String> map = new HashMap<>();
map.put(1, "One");
map.put(2, "Two");
map.forEach((key, value) -> System.out.println(key + " = " + value));

这种方法语法简洁,尤其适合使用 Lambda 表达式进行处理。

6. 数组

数组是相同数据类型的集合,可以存储固定大小的元素。

int[] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;
// 其他元素初始化

int[] primes = {2, 3, 5, 7, 11};
System.out.println(primes[0]); // 输出第一个元素

7. 面向对象编程

面向对象编程 (OOP) 是 Java 的核心概念,以下是几个重要的面向对象概念:

7.1 接口

接口是一种抽象类型,定义了类必须实现的方法。接口中的所有方法默认都是抽象的(没有方法体),且所有字段默认都是 public static final

interface Animal {
    void eat();
    void sleep();
}

class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog eats");
    }

    @Override
    public void sleep() {
        System.out.println("Dog sleeps");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
    }
}

7.2 抽象类

抽象类是不能被实例化的类,可以包含抽象方法和具体方法。抽象方法必须在子类中实现。

abstract class Animal {
    abstract void makeSound();

    public void sleep() {
        System.out.println("Sleeping...");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.sleep();
    }
}

7.3 继承

继承是指一个类(子类)继承另一个类(父类)的属性和方法。子类可以扩展或重写父类的方法。

class Animal {
    public void eat() {
        System.out.println("Animal eats");
    }
}

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

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

7.4 多态

多态允许同一个接口在不同的实现中表现出不同的行为。它是通过方法重载和方法重写实现的。

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

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

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

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        myDog.makeSound();
        myCat.makeSound();
    }
}

8. 输入输出 (I/O)

Java 的 I/O 库提供了丰富的类和接口,用于文件操作、数据流操作、网络通信等。

Scanner 类

Scanner 类是 Java 5 引入的,用于从各种输入源读取数据,例如控制台输入、文件、字符串等。它提供了一系列方便的方法来解析基本类型和字符串。

下面给的示例代码都是从控制台获取输入

import java.util.Scanner;

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

        System.out.print("请输入您的名字: ");
        String name = scanner.nextLine(); // 读取整行输入
        System.out.println("你好, " + name + "!");

        System.out.print("请输入您的年龄: ");
        int age = scanner.nextInt(); // 读取整数输入
        System.out.println("您 " + age + " 岁了!");

        scanner.close(); // 关闭 Scanner
    }
}
常用方法:
  • nextLine(): 读取一整行输入,返回一个字符串。
  • nextLine().charAt(0): 读取一行字符串中的第一个,一般用这个读取char类型变量。
  • nextInt(): 读取一个整数。
  • nextDouble(): 读取一个双精度浮点数。
  • nextBoolean(): 读取一个布尔值。
  • hasNext(): 检查是否有下一个输入。
  • hasNextLine(): 检查是否有下一行输入。
  • close(): 关闭 Scanner。

BufferedReader 类

BufferedReader 类用于从字符输入流中读取文本,提供了缓冲功能以提高读取效率。它通常与 InputStreamReader 一起使用,从标准输入或文件读取数据。

使用 BufferedReader 从终端读取数据
示例代码:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class BufferedReaderExample {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        System.out.print("请输入您的名字: ");
        String name = reader.readLine(); // 读取整行输入
        System.out.println("你好, " + name + "!");

        System.out.print("请输入您的年龄: ");
        int age = Integer.parseInt(reader.readLine()); // 读取整行输入并解析为整数
        System.out.println("您 " + age + " 岁了!");

        reader.close(); // 关闭 BufferedReader
    }
}
常用方法:
  • readLine(): 读取一整行输入,返回一个字符串。
  • close(): 关闭 BufferedReader。

对比 Scanner 和 BufferedReader

相同点:

  1. 都可以用于从终端、文件等源读取输入。
  2. 都提供了读取整行输入的方法:nextLine()readLine()

不同点:

  1. 功能

    • Scanner 提供了更多解析输入数据的方法,如 nextInt(), nextDouble() 等,可以直接读取基本类型数据。
    • BufferedReader 主要用于读取字符串,需要手动解析基本类型数据。
  2. 性能

    • BufferedReader 通常性能更高,因为它使用缓冲机制,适合读取大量文本数据。
    • Scanner 在方便性上有优势,但性能可能稍逊色。
  3. 使用场景

    • Scanner 更适合处理交互式的终端输入,或者需要解析各种基本类型数据的场景。
    • BufferedReader 更适合读取大量文本数据,或者需要更高效的输入操作的场景。

8.2 文件操作

Java 提供了多种文件操作类,如 FileReader, FileWriter, BufferedReader, BufferedWriter

读取文件

使用 BufferedReader 从文件中读取数据。

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

public class FileRead {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
写入文件

使用 BufferedWriter 将数据写入文件。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"))) {
            bw.write("Hello, World!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8.3 输出

将数据输出到控制台。

1. System.out.print()

  • 示例:
    // 输出内容到控制台,末尾没有换行
    System.out.print("Hello");
    System.out.print("World");
    
    输出:
    HelloWorld
    

2. System.out.println()

  • 示例:
    // 输出内容到控制台,并在内容后自动添加换行符。
    System.out.println("Hello");
    System.out.println("World");
    
  • 输出:
    Hello
    World
    

3. System.out.printf()

  • 用法: System.out.printf(formatString, arguments);
  • 示例:
    //  使用格式化字符串输出内容,类似于 C 语言中的 `printf`。允许你使用格式说明符控制输出的格式。
    int age = 25;
    double height = 1.75;
    System.out.printf("Age: %d years\n", age);
    System.out.printf("Height: %.2f meters\n", height);
    
    输出:
    Age: 25 years
    Height: 1.75 meters
    

常用格式说明符

  • 整数:
    • %d: 十进制整数
    • %x: 十六进制整数
  • 浮点数:
    • %f: 浮点数
    • %.2f: 浮点数,保留两位小数
  • 字符串:
    • %s: 字符串
  • 字符:
    • %c: 单个字符
  • 百分比:
    • %%: 输出百分号 %

总结

  • System.out.print(): 用于输出内容,不换行。
  • System.out.println(): 用于输出内容并换行。
  • System.out.printf(): 用于格式化输出内容。

9、Java 集合框架

String常用方法

1. 创建与初始化

  • String():创建一个空字符串。
  • String(String original):创建一个新的字符串,内容为指定的 String

2. 字符串操作

  • concat(String str):连接指定字符串到当前字符串末尾。
  • substring(int beginIndex):从指定索引开始,返回子字符串。
  • substring(int beginIndex, int endIndex):返回从 beginIndexendIndex 之间的子字符串。

3. 查找与比较

  • indexOf(String str):返回指定子字符串第一次出现的索引。
  • lastIndexOf(String str):返回指定子字符串最后一次出现的索引。
  • contains(CharSequence sequence):判断当前字符串是否包含指定字符序列。
  • equals(Object anObject):比较两个字符串的内容是否相等。
  • equalsIgnoreCase(String anotherString):忽略大小写比较两个字符串的内容是否相等。
  • compareTo(String anotherString):按字典顺序比较两个字符串。

4. 替换与转换

  • replace(char oldChar, char newChar):替换字符串中的所有指定字符为新字符。
  • replaceAll(String regex, String replacement):用正则表达式匹配并替换匹配的部分。
  • toLowerCase():将字符串转换为小写。
  • toUpperCase():将字符串转换为大写.
  • trim():去除字符串首尾的空白字符。

5. 分割与连接

  • split(String regex):根据正则表达式分割字符串,返回字符串数组。
  • join(CharSequence delimiter, CharSequence... elements):使用指定的分隔符连接多个字符序列。

6. 其他

  • charAt(int index):返回指定索引处的字符。java的String不可以通过str[0]这样的方式访问
  • length():返回字符串的长度。
  • isEmpty():判断字符串是否为空(长度为0)。
  • toCharArray():将字符串转换为字符数组。
  • startsWith(String prefix):判断字符串是否以指定的前缀开始。
  • endsWith(String suffix):判断字符串是否以指定的后缀结束。
  • matches(String regex):判断字符串是否匹配给定的正则表达式。

List 接口

List 是一个有序的集合,可以包含重复元素。常用实现类有 ArrayListLinkedList

ArrayList

ArrayList 是一个基于动态数组的数据结构,提供了快速的随机访问能力。它的主要特点是:

  • 动态调整数组大小:当元素超过数组容量时,ArrayList 会自动扩展。
  • 访问元素速度快:由于底层是数组,通过索引访问元素的时间复杂度为 O(1)。
  • 插入和删除操作相对较慢:插入或删除元素时,可能需要移动数组中的其他元素,时间复杂度为 O(n)。

常用方法:

  • add(E e): 添加元素到列表末尾。
  • get(int index): 获取指定索引位置的元素。
  • set(int index, E element): 替换指定索引位置的元素。
  • remove(int index): 移除指定索引位置的元素。
  • size(): 返回列表中元素的数量。

示例代码:

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        System.out.println("List: " + list);
        System.out.println("Element at index 1: " + list.get(1));

        list.set(1, "Blueberry");
        System.out.println("Updated List: " + list);

        list.remove(0);
        System.out.println("List after removal: " + list);
    }
}
LinkedList

LinkedList 是一个基于双向链表的数据结构,提供了高效的插入和删除操作。它的主要特点是:

  • 链表节点:每个元素都是一个节点,包含元素值以及指向前一个和后一个节点的指针。
  • 插入和删除速度快:插入和删除元素时只需调整指针,时间复杂度为 O(1)。
  • 访问元素速度慢:由于需要从头开始遍历链表,通过索引访问元素的时间复杂度为 O(n)。

常用方法:

  • add(E e): 添加元素到列表末尾。
  • get(int index): 获取指定索引位置的元素。
  • set(int index, E element): 替换指定索引位置的元素。
  • remove(int index): 移除指定索引位置的元素。
  • size(): 返回列表中元素的数量。

示例代码:

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

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        System.out.println("List: " + list);
        System.out.println("Element at index 1: " + list.get(1));

        list.set(1, "Blueberry");
        System.out.println("Updated List: " + list);

        list.remove(0);
        System.out.println("List after removal: " + list);
    }
}

Set 接口

Set 是一个不包含重复元素的集合。常用实现类有 HashSetTreeSet

HashSet

HashSet 基于哈希表实现,元素没有顺序。它的主要特点是:

  • 无序集合:元素没有特定的顺序。
  • 不允许重复元素:如果添加重复元素,HashSet 会忽略它。
  • 高效的插入、删除和查找操作:时间复杂度为 O(1)。

常用方法:

  • add(E e): 添加元素到集合中。
  • remove(Object o): 从集合中移除指定元素。
  • contains(Object o): 检查集合是否包含指定元素。
  • size(): 返回集合中元素的数量。

示例代码:

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        set.add("Apple"); // 重复元素

        System.out.println("Set: " + set);
        System.out.println("Set contains 'Banana': " + set.contains("Banana"));

        set.remove("Banana");
        System.out.println("Set after removal: " + set);
    }
}
TreeSet

TreeSet 基于红黑树实现,元素是有序的。它的主要特点是:

  • 有序集合:元素按照自然顺序或自定义顺序排序。
  • 不允许重复元素:如果添加重复元素,TreeSet 会忽略它。
  • 较高的插入、删除和查找操作性能:时间复杂度为 O(log n)。

常用方法:

  • add(E e): 添加元素到集合中。
  • remove(Object o): 从集合中移除指定元素。
  • contains(Object o): 检查集合是否包含指定元素。
  • size(): 返回集合中元素的数量。

示例代码:

import java.util.Set;
import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("Banana");
        set.add("Apple");
        set.add("Cherry");

        System.out.println("Set: " + set);
        System.out.println("Set contains 'Banana': " + set.contains("Banana"));

        set.remove("Banana");
        System.out.println("Set after removal: " + set);
    }
}

Map 接口

Map 是一个键值对的集合,每个键最多只能关联一个值。常用实现类有 HashMapTreeMap

HashMap

HashMap 基于哈希表实现,键值对没有顺序。它的主要特点是:

  • 无序集合:键值对没有特定的顺序。
  • 不允许重复键:如果添加重复键,HashMap 会覆盖旧值。
  • 高效的插入、删除和查找操作:时间复杂度为 O(1)。

常用方法:

  • put(K key, V value): 添加键值对到映射中。
  • get(Object key): 获取指定键的值。
  • remove(Object key): 从映射中移除指定键值对。
  • containsKey(Object key): 检查映射是否包含指定键。
  • size(): 返回映射中键值对的数量。

示例代码:

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

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);

        System.out.println("Map: " + map);
        System.out.println("Value for 'Banana': " + map.get("Banana"));

        map.remove("Banana");
        System.out.println("Map after removal: " + map);
    }
}
TreeMap

TreeMap 基于红黑树实现,键值对是有序的。它的主要特点是:

  • 有序集合:键值对按照键的自然顺序或自定义顺序排序。
  • 不允许重复键:如果添加重复键,TreeMap 会覆盖旧值。
  • 较高的插入、删除和查找操作性能:时间复杂度为 O(log n)。

常用方法:

  • put(K key, V value): 添加键值对到映射中。
  • get(Object key): 获取指定键的值。
  • remove(Object key): 从映射中移除指定键值对。
  • containsKey(Object key): 检查映射是否包含指定键。
  • size(): 返回映射中键值对的数量。

示例代码:

import java.util.Map;
import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();
        map.put("Banana", 2);
        map.put("Apple", 1);
        map.put("Cherry", 3);

        System.out.println("Map: " + map);
        System.out.println("Value for 'Banana': " + map.get("Banana"));

        map.remove("Banana");
        System.out.println("Map after removal: " + map);
    }
}

Queue 接口

Queue 是一个先进先出的集合,常用实现类有 LinkedListPriorityQueue

LinkedList

LinkedList 实现了 Queue 接口,提供了基于链表的队列实现。它的主要特点是:

  • 双向链表:可以作为队列(FIFO)和双端队列(Deque)使用。
  • 高效的插入和删除操作:时间复杂度为 O(1)。

常用方法:

  • add(E e): 将指定元素插入此队列的末尾。
  • offer(E e): 将指定元素插入此队列的末尾,如果成功则返回 true,如果队列已满则返回 false(一般不检查队列是否满)。
  • remove(): 检索并移除此队列的头部元素。
  • poll(): 检索并移除此队列的头部元素,如果此队列为空,则返回 null
  • element(): 检索但不移除此队列的头部元素。
  • peek(): 检索但不移除此队列的头部元素,如果此队列为空,则返回 null

示例代码:

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.add("Apple");
        queue.offer("Banana");
        queue.add("Cherry");

        System.out.println("Queue: " + queue);
        System.out.println("Head of the queue: " + queue.peek());

        queue.remove();
        System.out.println("Queue after removal: " + queue);

        queue.poll();
        System.out.println("Queue after poll: " + queue);
    }
}
PriorityQueue

PriorityQueue 是一个基于优先级堆(最小堆或最大堆)的队列,元素按自然顺序或自定义顺序排序。它的主要特点是:

  • 无界优先级队列:元素按照优先级排序,不一定是先进先出(FIFO)。
  • 默认最小堆:自然顺序为最小堆,可自定义比较器实现最大堆。
  • 高效的插入和删除操作:时间复杂度为 O(log n)。

常用方法与 LinkedList 类似:

  • add(E e): 将指定元素插入此队列。
  • offer(E e): 将指定元素插入此队列。
  • remove(): 检索并移除此队列的头部元素。
  • poll(): 检索并移除此队列的头部元素,如果此队列为空,则返回 null
  • element(): 检索但不移除此队列的头部元素。
  • peek(): 检索但不移除此队列的头部元素,如果此队列为空,则返回 null

示例代码:

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new PriorityQueue<>();
        queue.add("Banana");
        queue.offer("Apple");
        queue.add("Cherry");

        System.out.println("PriorityQueue: " + queue);
        System.out.println("Head of the queue: " + queue.peek());

        queue.remove();
        System.out.println("PriorityQueue after removal: " + queue);

        queue.poll();
        System.out.println("PriorityQueue after poll: " + queue);
    }
}