java日常总结

一、int及String类型转换

在 Java 中可以通过以下两种方式将 `int` 类型转换为 `String` 类型：

1. 使用 `String.valueOf()` 方法：可以通过调用 `String` 类的 `valueOf()` 方法，并将要转换的 `int` 类型参数作为方法参数传入来将 `int` 类型转换为 `String` 类型。示例如下：

```java
int num = 123; // 原始数据
String str = String.valueOf(num); // 将 int 类型转换为 String 类型
```

2. 使用 `Integer.toString()` 方法：可以通过调用 `Integer` 类的 `toString()` 静态方法，并将要转换的 `int` 类型参数作为方法参数传入来将 `int` 类型转换为 `String` 类型。示例如下：

```java
int num = 123; // 原始数据
String str = Integer.toString(num); // 将 int 类型转换为 String 类型
```

两种方式的结果是相同的，都可以将 `int` 类型转换为相应的 `String` 类型。需要注意的是，如果要将 `String` 类型转换为 `int` 类型，可以使用 `Integer.parseInt()` 方法。

二、isNotEmpty用法

`ObjectUtils.isNotEmpty(obj)` 是 Apache Commons Lang 3 中提供的方法，用于判断给定对象是否非空（not empty）。如果对象为非空值，则返回 `true`，否则返回 `false`。

在 `ObjectUtils.isNotEmpty(obj)` 方法中，会调用 `org.apache.commons.lang3.ObjectUtils#isEmpty(Object obj)` 方法来判断对象是否为空，如果为空，则返回 `false`，否则返回 `true`。

对象为空的条件包括：

- 对象为 `null`
- 对象为数组类型，且数组长度为 0
- 对象为 `CharSequence` 类型（即字符串类型），且长度为 0

需要注意的是，如果对象实现了 `java.util.Collection` 接口，则空集合会被视为空对象，因此不会返回 `true`。如果需要判断集合是否为空，请使用 `CollectionUtils.isEmpty(Collection coll)` 方法。

总之，`ObjectUtils.isNotEmpty(obj)` 方法被用来简化对对象非空判断的代码，避免出现重复的判断逻辑。

三、Java判等

在 Java 中，比较两个变量是否相等可以使用以下几种方式：

1. 使用 `==` 运算符：`==` 运算符用于比较两个变量的值是否相等。它不会自动进行类型转换，只有当两个变量的类型相同时才能使用。因此，使用 `==` 运算符比较两个 `int` 类型的变量时，只有它们的值相等才会返回 `true`。例如：

```java
int a = 10;
int b = 20;
boolean result = a == b; // 返回 false
```

2. 使用 `equals()` 方法：`equals()` 方法是 `Object` 类的方法，用于比较两个对象是否相等。对于基本数据类型的包装类（如 `Integer` 类），它实现了 `equals()` 方法，可以直接使用。例如：

```java
Integer a = 10;
Integer b = 20;
boolean result = a.equals(b); // 返回 false
```

3. 使用 `Objects.equals()` 方法：`Objects.equals()` 方法是 `java.util.Objects` 类中的静态方法，用于比较两个对象是否相等。如果两个对象都为 `null`，返回 `true`。如果其中一个对象为 `null`，返回 `false`。如果两个对象不为 `null`，则调用第一个对象的 `equals()` 方法进行比较。例如：

```java
Integer a = 10;
Integer b = 20;
boolean result = Objects.equals(a, b); // 返回 false
```

需要注意的是，虽然 `==` 运算符可以用于比较基本数据类型的值，但对于对象类型的变量，则只能比较它们是否指向同一个对象。如果想要比较两个对象的值是否相等，应该使用 `equals()` 方法或 `Objects.equals()` 方法。

四、抛异常处理

在 Java 中，可以通过抛出异常来处理代码中的错误和异常情况。常见的抛出异常的方法包括：

1. 使用 `throw` 关键字直接抛出异常，示例如下：

```java
public void method() throws Exception {
    // do something
    throw new Exception("something wrong"); // 抛出异常
}
```

上述示例中，定义了一个 `method()` 方法，使用 `throw` 关键字抛出了一个新的 `Exception` 异常对象。在方法声明中使用 `throws` 关键字声明了 `method()` 方法可能抛出的异常类型（即 `Exception` 类型）。

2. 使用 `try-catch` 块来捕获并处理异常，示例如下：

```java
public void method() {
    try {
        // do something
    } catch (IOException e) { // 捕获 IOException 异常
        e.printStackTrace();
    } catch (Exception e) { // 捕获其他异常
        e.printStackTrace();
    } finally { // 可选的 finally 块
        // do something
    }
}
```

上述示例中，定义了一个 `method()` 方法

，并在其中使用了 `try-catch-finally` 块来处理可能发生的异常。在 `try` 块中执行需要经过异常检查的代码，如果检测到异常，则会跳转到 `catch` 块，并执行与异常类型相匹配的代码块进行处理。可以使用多个 `catch` 块来处理不同类型的异常。在 `finally` 块中定义一些无论异常是否发生都需要执行的代码，例如资源释放等。

3. 自定义异常并抛出，示例如下：

```java
public class MyException extends Exception {
    public MyException(String errMsg) {
        super(errMsg);
    }
}

public void method() throws MyException {
    // do something
    throw new MyException("something wrong"); // 抛出自定义异常
}
```

上述示例中，定义了一个 `MyException` 类作为自定义异常类，继承了 `Exception` 类，同时提供了一个带有字符串参数的构造函数，并在该构造函数中调用父类的构造函数。在 `method()` 方法中抛出自定义异常。使用 `throws` 关键字在方法声明中声明可能抛出的异常类型为 `MyException`。

五、JSONObject 和 JSONArray

在 Java 中，可以使用 `JSONObject` 和 `JSONArray` 类来操作 JSON 数据。`JSONObject` 类表示一个 JSON 对象，`JSONArray` 类表示一个 JSON 数组。这两个类是 Java 提供的操作 JSON 数据的基础类，可以用来解析、生成、修改 JSON 数据。下面分别介绍 `JSONObject` 和 `JSONArray` 类的使用方法。

## JSONObject

`JSONObject` 类表示一个 JSON 对象。以下是 `JSONObject` 类的一些常用方法：

1. 从字符串解析 JSON 对象。可以使用 `JSONObject.parseObject()` 方法从一个 JSON 字符串中解析出一个 `JSONObject` 对象。例如：

   ```java
   String jsonString = "{\"name\":\"John\", \"age\":30, \"city\":\"New York\"}";
   JSONObject jsonObject = JSONObject.parseObject(jsonString);
   ```

2. 从 `Map` 对象创建 JSON 对象。可以使用 `JSONObject` 类的构造函数，从 `Map` 对象中创建一个 `JSONObject` 对象。例如：

   ```java
   Map<String, Object> map = new HashMap<>();
   map.put("

name", "John");
   map.put("age", 30);
   map.put("city", "New York");
   JSONObject jsonObject = new JSONObject(map);
   ```

3. 获取 JSON 对象中的属性值。可以使用 `get*()` 系列方法从 `JSONObject` 中获取对应属性的值。例如：

   ```java
   String name = jsonObject.getString("name");
   int age = jsonObject.getIntValue("age");
   String city = jsonObject.getString("city");
   ```

4. 添加属性到 JSON 对象中。可以使用 `put()` 方法向 `JSONObject` 中添加属性。例如：

   ```java
   jsonObject.put("company", "ABC");
   ```

5. 将 JSON 对象转换为字符串。可以使用 `toJSONString()` 方法将 `JSONObject` 对象转换为 JSON 字符串。例如：

   ```java
   String jsonString = jsonObject.toJSONString();
   ```

## JSONArray

`JSONArray` 类表示一个 JSON 数组。以下是 `JSONArray` 类的一些常用方法：

1. 从字符串解析 JSON 数组。可以使用 `JSONArray.parseArray()` 方法从一个 JSON 字符串中解析出一个 `JSONArray` 数组对象。例如：

   ```java
   String jsonString = "[\"Apple\", \"Banana\", \"Orange\"]";
   JSONArray jsonArray = JSONArray.parseArray(jsonString);
   ```

2. 从 `List` 对象创建 JSON 数组。可以使用 `JSONArray` 类的构造函数，从 `List` 对象中创建一个 `JSONArray` 数组对象。例如：

   ```java
   List<String> list = new ArrayList<>();
   list.add("Apple");
   list.add("Banana");
   list.add("Orange");
   JSONArray jsonArray = new JSONArray(list);
   ```

3. 获取 JSON 数组中的元素值。可以使用 `get*()` 系列方法从 `JSONArray` 中获取对应索引位置的元素值。例如：

   ```java
   String element0 = jsonArray.getString(0);
   String element1 = jsonArray.getString(1);
   String eleme

nt2 = jsonArray.getString(2);
   ```

4. 添加元素到 JSON 数组中。可以使用 `add()` 方法向 `JSONArray` 中添加元素。例如：

   ```java
   jsonArray.add("Grape");
   ```

5. 将 JSON 数组转换为字符串。可以使用 `toJSONString()` 方法将 `JSONArray` 数组对象转换为 JSON 字符串。例如：

   ```java
   String jsonString = jsonArray.toJSONString();
   ```

以上就是 `JSONObject` 和 `JSONArray` 类的一些常用方法，可以通过这些方法来操作 JSON 数据。在实际开发中，我们通常会使用第三方库如 `Jackson` 或 `Gson` 来进行 JSON 数据的处理，这些库提供了更丰富的操作接口和更高的性能。

六、context

在 Java 中，Context 是 Android 平台中的概念，是一个全局的、应用级别的上下文环境。它可以让应用程序及其组件（如 Activity、Service、BroadcastReceiver）访问应用程序的资源和系统服务，如访问应用程序的布局资源、字符串资源、Drawable 图形资源，以及访问存储在 SharedPreferences 中的数据等等。

在 Android 中，Context 是一个抽象类，主要具有以下几种功能：

1. 访问应用程序的资源

   Context 可以访问应用程序的资源，如布局、字符串、Drawable 图形等。可以使用 `getApplication()`, `getApplicationContext()`, `getResources()` 等方法获取 Context 对象，从而访问应用程序的资源。

2. 启动组件

   Context 可以启动组件，如 Activity、Service、BroadcastReceiver。可以使用 `startActivity()`, `startService()`, `sendBroadcast()` 等方法启动组件。

3. 获取系统服务

   Context 可以访问系统的服务，如获取电源管理器、获取网络状态等。可以使用 `getSystemService()` 方法获取系统服务。

在 Android 应用程序中，每一个组件（Activity、Service、BroadcastReceiver）的创建都必须伴随一个 Context 对象的创建。因此，Context 在 Android 应用程序中十分重要，它关联了整个应用程序的上下文环境，提供了许多操作应用程序资源和系统服务的接口。