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
)
对于集合类(如 List
、Set
等),可以使用 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
相同点:
- 都可以用于从终端、文件等源读取输入。
- 都提供了读取整行输入的方法:
nextLine()
和readLine()
。
不同点:
-
功能:
Scanner
提供了更多解析输入数据的方法,如nextInt()
,nextDouble()
等,可以直接读取基本类型数据。BufferedReader
主要用于读取字符串,需要手动解析基本类型数据。
-
性能:
BufferedReader
通常性能更高,因为它使用缓冲机制,适合读取大量文本数据。Scanner
在方便性上有优势,但性能可能稍逊色。
-
使用场景:
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)
:返回从beginIndex
到endIndex
之间的子字符串。
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
是一个有序的集合,可以包含重复元素。常用实现类有 ArrayList
和 LinkedList
。
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
是一个不包含重复元素的集合。常用实现类有 HashSet
和 TreeSet
。
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
是一个键值对的集合,每个键最多只能关联一个值。常用实现类有 HashMap
和 TreeMap
。
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
是一个先进先出的集合,常用实现类有 LinkedList
和 PriorityQueue
。
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);
}
}