java 基础
基础数据类型，方法，类，异常处理：Java 零基础入门学习（小白也能看懂！）_java零基础自学-CSDN博客
List
在Java中，List 接口是集合框架中非常重要的一个接口，它提供了存储和操作有序集合的方法。List 是一个接口，因此不能直接实例化，但可以通过其实现类（如 ArrayList, LinkedList, Vector 等）来使用。
List 接口的主要实现类
- ArrayList: 动态数组实现，适用于随机访问和迭代，对于频繁的增删操作效率较低。
- LinkedList: 双向链表实现，适用于频繁的增删操作，但对于随机访问效率较低。
- Vector: 与 ArrayList 类似，但 Vector 是线程同步的，适合多线程环境。
- CopyOnWriteArrayList: 线程安全的 List 实现，适用于读多写少的场景。
创建 List
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
// 创建一个空的 ArrayList
List names = new ArrayList<>();
// 或者创建一个带有初始容量的 ArrayList
List namesWithInitialCapacity = new ArrayList<>(10);
// 创建一个包含初始元素的 ArrayList
List initialNames = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
}
} 添加元素
names.add("David");
names.add(1, "Eve"); // 在索引 1 处插入 "Eve"获取元素
String firstElement = names.get(0); // 获取第一个元素 通过索引删除元素
names.remove("David"); // 移除值为 "David" 的元素
names.remove(0); // 移除索引为 0 的元素遍历 List
// 使用 for-each 循环
for (String name : names) {
System.out.println(name);
}
// 使用传统的 for 循环
for (int i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}
// 使用 Java 8 的 Stream API
names.stream().forEach(System.out::println);查找元素
int index = names.indexOf("Charlie"); // 查找 "Charlie" 的索引位置
boolean contains = names.contains("Charlie"); // 判断是否包含 "Charlie"替换元素
names.set(0, "Alex"); // 将索引 0 处的元素替换为 "Alex"排序
Collections.sort(names); // 自然排序（对于 String，按字母顺序）
Collections.sort(names, Comparator.reverseOrder()); // 逆序排序示例代码
下面是一个完整的示例代码，演示了如何使用 ArrayList：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
List names = new ArrayList<>();
names.add("David");
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// 输出原始列表
System.out.println("Original list: " + names);
// 在索引 1 处插入 "Eve"
names.add(1, "Eve");
// 查找 "Charlie" 的索引位置
int index = names.indexOf("Charlie");
System.out.println("Index of Charlie: " + index);
// 判断是否包含 "Charlie"
boolean contains = names.contains("Charlie");
System.out.println("Contains Charlie: " + contains);
// 替换索引 0 处的元素
names.set(0, "Alex");
// 自然排序
Collections.sort(names);
System.out.println("Sorted list: " + names);
// 逆序排序
Collections.sort(names, Comparator.reverseOrder());
System.out.println("Reverse sorted list: " + names);
// 移除 "Alex"
names.remove("Alex");
// 遍历列表
System.out.println("Final list:");
for (String name : names) {
System.out.println(name);
}
}
} 总结
List 接口提供了丰富的操作方法，可以根据具体需求选择合适的实现类。ArrayList 适用于需要快速随机访问的场景，而 LinkedList 更适合需要频繁插入和删除元素的场景。通过上面的示例，你应该能够理解和使用 List 接口及其常见实现类。
Map
在Java中，Map 接口是集合框架中的一个重要组成部分，用于存储键值对（key-value pairs）。Map 接口本身不能直接实例化，但可以通过其不同的实现类来使用。下面详细介绍几种常用的 Map 实现类及其基本操作。
主要的 Map 实现类
- HashMap: 最常用的 Map 实现类，提供了良好的性能，允许 null 键和 null 值，但不是线程安全的。
- LinkedHashMap: 保持了插入顺序，适合需要按照插入顺序或访问顺序进行遍历的情况。
- TreeMap: 按照键的自然顺序或自定义比较器进行排序，适合需要有序的键值对。
- ConcurrentHashMap: 线程安全的 Map 实现，适用于多线程环境，性能较好。
- WeakHashMap: 使用弱引用作为键，适合用于缓存场景，当没有强引用指向键时，键会被垃圾回收。
创建 Map
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
// 创建一个空的 HashMap
Map scores = new HashMap<>();
}
} 添加元素
scores.put("David", 95);
scores.put("Eve", 88);获取元素
Integer score = scores.get("David"); // 获取 "David" 的分数
Integer scoreOrDefault = scores.getOrDefault("David", 0); // 如果不存在则返回默认值 0删除元素
scores.remove("David"); // 移除键为 "David" 的元素更新元素
scores.remove("David"); // 移除键为 "David" 的元素检查元素
boolean containsKey = scores.containsKey("David"); // 是否包含键 "David"
boolean containsValue = scores.containsValue(92); // 是否包含值 92遍历 Map
// 使用 for-each 循环遍历键
for (String key : scores.keySet()) {
System.out.println(key + ": " + scores.get(key));
}
// 使用 for-each 循环遍历键值对
for (Map.Entry entry : scores.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 使用 Java 8 的 Stream API
scores.forEach((key, value) -> System.out.println(key + ": " + value)); Map
在实际开发中，value的值可能是任意类型，可以使用Object指定value的类型，因为 Object 是 Java 中所有类的超类。这意味着你可以将任何类型的对象放入 Map 中，只要它们可以隐式地转换为 Object 类型，这是 Java 类型系统的特性决定的
import java.util.HashMap;
import java.util.Map;
public class DataStorageExample {
public static void main(String[] args) {
Map data = new HashMap<>();
// 存储不同类型的数据
data.put("name", "Alice"); // String
data.put("age", 30); // Integer
data.put("isStudent", false); // Boolean
data.put("scores", new int[]{90, 85, 95}); // int[]
data.put("address", new Address("123 Elm St", "Springfield")); // 自定义对象
// 输出 Map 中的数据
for (Map.Entry entry : data.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
System.out.println("Key: " + key + ", Value: " + value);
}
}
}
// 定义一个简单的自定义类
static class Address {
String street;
String city;
public Address(String street, String city) {
this.street = street;
this.city = city;
}
@Override
public String toString() {
return street + ", " + city;
}
} 注意事项
虽然 Map
类型安全性：由于所有值都是 Object 类型，因此在访问这些值时需要进行显式的类型转换。如果类型转换错误，会导致 ClassCastException。为了避免这种情况，最好在读取时进行类型检查或使用泛型方法。
类型检查：在读取 Map 中的值时，可以通过 instanceof 关键字进行类型检查：
for (String key: data.keySet()) {
Object value = data.get(key);
if (value instanceof Integer) {
System.out.printf("%s : %d \n", key, (Integer)value);
} else if (value instanceof String) {
System.out.printf("%s : %s \n", key, (String)value);
}
}
泛型方法：如果经常需要处理特定类型的值，可以考虑使用泛型方法来减少类型转换的工作量：
String name = getValue(data, "name", String.class);
Integer age = getValue(data, "age", Integer.class);
public static T getValue(Map map, String key, Class clazz) {
Object value = map.get(key);
if (value == null && clazz.isInstance(value)) {
return null;
}
return clazz.cast(value);
} 示例代码
下面是一个完整的示例代码，演示了如何使用 HashMap：
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapExample {
public static void main(String[] args) {
Map scores = new HashMap<>();
// 添加元素
scores.put("Alice", 100);
scores.put("Bob", 90);
scores.put("Charlie", 85);
// 输出原始 Map
System.out.println("Original map: " + scores);
// 更新元素
scores.put("Charlie", 90);
// 删除元素
scores.remove("Bob");
// 检查元素
boolean containsKey = scores.containsKey("Charlie");
System.out.println("Contains key 'Charlie': " + containsKey);
// 获取元素
Integer score = scores.get("Alice");
System.out.println("Score of Alice: " + score);
// 遍历 Map
System.out.println("Final map:");
for (Map.Entry entry : scores.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
Map data = new HashMap<>();
// 存储不同类型的数据
data.put("name", "Alice"); // String
data.put("age", 30); // Integer
data.put("isStudent", false); // Boolean
data.put("scores", new int[]{90, 85, 95}); // int[]
data.put("address", new Address("123 Elm St", "Springfield")); // 自定义对象
// 输出 Map 中的数据
for (Map.Entry entry : data.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
System.out.println("Key: " + key + ", Value: " + value);
}
// 泛型取值
String name = getValue(data, "name", String.class);
Integer age = getValue(data, "age", Integer.class);
}
public static T getValue(Map map, String key, Class clazz) {
Object value = map.get(key);
if (value == null && clazz.isInstance(value)) {
return null;
}
return clazz.cast(value);
}
}
// 定义一个简单的自定义类
static class Address {
String street;
String city;
public Address(String street, String city) {
this.street = street;
this.city = city;
}
@Override
public String toString() {
return street + ", " + city;
}
} 总结
Map 接口提供了丰富的操作方法，可以根据具体需求选择合适的实现类。HashMap 适用于大多数场景，而 LinkedHashMap 和 TreeMap 分别用于保持插入顺序或进行排序。ConcurrentHashMap 适用于多线程环境，WeakHashMap 适用于缓存场景。通过上面的示例，你应该能够理解和使用 Map 接口及其常见实现类。
时间操作
java基础之时间类型_java 时间格式-CSDN博客
// 获取当前时间
Date date = new Date();
System.out.println(date);
// 获取时间戳
System.out.println(date.getTime());
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// String -> Date
String s = "2024-09-12 00:00:00";
try {
Date d = formatter.parse(s);
System.out.println(d);
}catch (ParseException e){
e.printStackTrace();
}
// Date -> String
String ss = formatter.format(date);
System.out.println(ss);配置文件操作
如何在Java中进行配置文件的读写？_java 读写配置文件-CSDN博客
Properties文件
myconf.properties:
#Updated properties file
#Thu Sep 12 19:12:07 CST 2024
db.user=root
db.pass=123456
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
public class ConfigReader {
public static void testConf() {
Properties prop = new Properties();
try (FileInputStream fis = new FileInputStream("myconf.properties")) {
// 读取文件内容
prop.load(fis);
String user = prop.getProperty("db.user");
String pass = prop.getProperty("db.pass");
System.out.println(user);
System.out.println(pass);
prop.setProperty("db.host", "127.0.0.1");
prop.setProperty("db.port", "3306");
// 如果需要将修改后的属性保存回文件
try (FileOutputStream fos = new FileOutputStream("myconf.properties")) {
prop.store(fos, "Updated properties file");
}
} catch (IOException e) {
e.printStackTrace(); // 记录详细的异常信息
}
}
public static void main(String[] args) {
testConf();
}
}YAML文件
public static void yamlConf() {
Yaml ym = new Yaml(); // 先安装 snakeyaml
Map map = new HashMap<>();
map.put("db.host", "127.0.0.1");
map.put("db.port", 3306);
map.put("db.user", "root");
map.put("db.pass", "123456");
// 写入yaml
try (Writer w = new FileWriter("myconf.yaml")) {
ym.dump(map, w);
}catch (IOException e) {
e.printStackTrace();
}
// 读取yaml
try (InputStream r = new FileInputStream("myconf.yaml")){
Map data = ym.load(r);
System.out.println(data);
String host = (String) data.get("db.host");
Integer port = (Integer) data.get("db.port");
System.out.println(host + ":" + port);
}catch (IOException e) {
e.printStackTrace();
}
} 多线程
JAVA之多线程_java多线程-CSDN博客
依赖库安装 https://mvnrepository.com/
java与mysql连接 使用mysql-connector-java连接msql-CSDN博客
Maven
安装 Maven – Download Apache Maven
Linux系统上安装Maven的完整指南_linux 安装maven-CSDN博客
使用
了解Maven,并配置国内源_maven 国内源-CSDN博客
操作MySQL
使用 mysql-connector-java-8.0.30.jar 操作数据库CURD
import com.mysql.cj.jdbc.MysqlDataSource;
import java.sql.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
String host = "127.0.0.1";
String port = "3306";
String databaseName = "mydatabase";
String url = "jdbc:mysql://" + host + ":" + port + "/" + databaseName;
String user = "root";
String pass = "xxxxxx";
DataBaseCURD dataBaseCURD = new DataBaseCURD(url, user, pass);
Boolean isConn = dataBaseCURD.getConnection();
if (!isConn) {
System.out.println("Connection is null");
}else {
String tableSql = "CREATE TABLE IF NOT EXISTS users (" +
"id INT AUTO_INCREMENT PRIMARY KEY," +
"name VARCHAR(100)," +
"email VARCHAR(150))";
Boolean createRes = dataBaseCURD.createTable(tableSql);
String insertSql = "INSERT INTO users (name, email) VALUES (?, ?)";
Map map1 = new HashMap<>();
Map map2 = new HashMap<>();
map1.put("id", "1");
map1.put("name", "A");
map1.put("email", "[email protected]");
map2.put("id", "2");
map2.put("name", "B");
map2.put("email", "[email protected]");
List> insertData = new ArrayList<>(Arrays.asList(map1, map2));
Boolean insertRes = dataBaseCURD.InsertData(insertSql, insertData);
String updateSql = "UPDATE users SET email=? WHERE id=?";
Map map3 = new HashMap<>();
map3.put("id", "1");
map3.put("email", "[email protected]");
List> updateData = new ArrayList<>(Arrays.asList(map3));
Boolean updateRes = dataBaseCURD.updateData(updateSql, updateData);
String deleteSql = "DELETE FROM users WHERE id=?";
Map map4 = new HashMap<>();
map4.put("id", "1");
List> deleteData = new ArrayList<>(Arrays.asList(map4));
Boolean deleteRes = dataBaseCURD.deleteData(deleteSql, deleteData);
String serlectSql = "SELECT * FROM users";
dataBaseCURD.selectData(serlectSql);
dataBaseCURD.Close();
}
}
}
class DataBaseCURD{
Connection conn;
String url;
String user;
String password;
public DataBaseCURD(String url, String user, String password){
this.url = url;
this.user = user;
this.password = password;
}
public Boolean getConnection() {
try {
MysqlDataSource dataSource = new MysqlDataSource();
dataSource.setUrl(this.url);
dataSource.setUser(this.user);
dataSource.setPassword(this.password);
this.conn = dataSource.getConnection();
System.out.println("Connection is ok");
return true;
}catch (SQLException e){
System.out.println("Connection failed");
e.printStackTrace();
}
return false;
}
public Boolean createTable(String sql) {
Statement stmt = null;
try {
stmt = this.conn.createStatement();
stmt.executeUpdate(sql);
System.out.println("Table created");
return true;
}catch (SQLException e){
System.out.println("Table create failed");
e.printStackTrace();
}finally {
try {
if (stmt != null) {
stmt.close();
}
}catch (SQLException e){
e.printStackTrace();
}
}
return false;
}
public Boolean InsertData(String sql, List> data) {
PreparedStatement stmt = null;
try {
stmt = this.conn.prepareStatement(sql);
for (Map m: data){
// int id = Integer.parseInt(m.get("id"));
String name = m.get("name");
String email = m.get("email");
// System.out.println(name + " " + email);
stmt.setString(1, name);
stmt.setString(2, email);
int row = stmt.executeUpdate();
}
System.out.println("Insert successful");
return true;
}catch (SQLException e){
System.out.println("Insert failed");
e.printStackTrace();
}finally {
try {
if (stmt != null) {
stmt.close();
}
}catch (SQLException e){
e.printStackTrace();
}
}
return false;
}
public Boolean updateData(String sql, List> data) {
PreparedStatement stmt = null;
try {
for (Map m: data) {
stmt = this.conn.prepareStatement(sql);
int id = Integer.parseInt(m.get("id"));
String email = m.get("email");
stmt.setString(1, email); // 传递String类型的值 ， 这里的1表示替换sql语句中的第一个？号
stmt.setInt(2, id); // 传递int类型的值
int row = stmt.executeUpdate();
}
System.out.println("Table updated");
return true;
}catch (SQLException e){
System.out.println("Update failed");
}finally {
try {
if (stmt != null) {stmt.close();}
}catch (SQLException e){
e.printStackTrace();
}
}
return false;
}
public Boolean deleteData(String sql, List> data) {
PreparedStatement stmt = null;
try {
stmt = this.conn.prepareStatement(sql);
for (Map m: data) {
int id = Integer.parseInt(m.get("id"));
stmt.setInt(1, id);
int row = stmt.executeUpdate();
}
System.out.println("Data Delete successful");
return true;
}catch (SQLException e){
System.out.println("Data Delete failed");
}finally {
try {
if (stmt != null) {
stmt.close();
}
}catch (SQLException e){
e.printStackTrace();
}
}
return false;
}
public void selectData(String sql) {
Statement stmt = null;
ResultSet rs = null;
try {
stmt = this.conn.createStatement();
rs = stmt.executeQuery(sql);
if (rs != null) {
try {
while (rs.next()){
int id = rs.getInt("id"); // 取int类型的值
String name = rs.getString("name"); // 取String类型的值
String email = rs.getString("email");
System.out.println("id: " + id + " name: " + name + " email: " + email);
}
}catch (Exception e){
e.printStackTrace();
}
}
}catch (SQLException e){
e.printStackTrace();
}finally {
try {
// 注意close顺序 stmt,rs,conn
// rs.next() 之后再close
if (stmt != null) {stmt.close();}
if (rs != null) {rs.close();}
}catch (SQLException e){
e.printStackTrace();
}
}
}
public void Close(){
try {
if (conn != null){conn.close();}
System.out.println("Connection closed");
}catch (SQLException e){
e.printStackTrace();
}
}
}