Java中String类-ArrayList集合-常用API

拼搏现实的明天。 2023-09-28 15:33 86阅读 0赞

#### 文章目录 ####

*  String-ArrayList
 *   *  String类
     *   *  String类的介绍
         *  String创建方式
         *  String常用API
         *   *  1.字符串比较
             *  2.其他常用API
     *  ArrayList
     *   *  ArrayList集合
         *  ArrayList常用API
         *  案例练习
         *   *  遍历并删除元素值
             *  学生信息系统的数据搜索

## String-ArrayList ##

### String类 ###

> **API （Application Programming Interface,应用程序编程接口）**:
> 
>  *  Java写好的技术(功能代码)，咱们可以直接调用。
>  *  Oracle 也为Java提供的这些功能代码提供了相应的 API文档(技术使用说明书) 。

[JavaAPI文档][JavaAPI]: http://www.oracle.com/technetwork/java/javase/downloads/index.html

> **学习目标** :
> 
>  *  **String定义变量存储字符串**: 需要知道如何创建字符串对象，并使用String定义变量指向该字符串对象。
>  *  **String的内存原理**: 字符串对象在内存中的原理是什么样。能够解决一些字符串常见面试题
>  *  **String类提供了哪些API**: 够说出并使用String类提供的操作字符串的功能：遍历、替换、截取、相等，包含…
>  *  **String解决实际案例**: 能够利用String的常用API去解决实际场景的业务需求，真正做到学以致用

#### String类的介绍 ####

**String 概述** :

*  java.lang.String 类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该字符串。
 *  Java 程序中的所有字符串文字（例如“abc”）都为此类的对象。

String name = "chenyq";
    String address = "成都市";

**String类的特点**:

*  **String其实常被称为不可变字符串类型，它的对象在创建后不能被更改。**

**从下面代码可以看出字符串变量str指向的字符串对象值已经改变，那为何还说字符串不可变呢?**

public static void main(String[] args) {
        
    		String str = "aaa";
    		str += "bbb";
    		str += "ccc";
    		System.out.println(str); // aaabbbccc
    }

*  **这是因为以“”方式给出的字符串对象，在字符串常量池中存储。**
 *  **每次字符串相加后, 会形成一个新的字符串对象, 而str这个变量保存的地址会指向新的字符串对象, 原来的字符串并没有改变**

**小结** :

*  **String变量每次的修改其实都是产生并指向了新的字符串对象。**
 *  **原来的字符串对象都是没有改变的，所以称不可变字符串。**

#### String创建方式 ####

**创建字符串对象的2种方式** :

*  **方式一**：直接使用“”得到一个字符串对象定义。（推荐方式）

String name = "chenyq";

*  **方式二**：通过String类的构造器创建对象。

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public String()</td> 
   <td>创建一个空白字符串对象，不含有任何内容</td> 
  </tr> 
  <tr> 
   <td>public String(String original)</td> 
   <td>根据传入的字符串内容，来创建字符串对象</td> 
  </tr> 
  <tr> 
   <td>public String(char[] chs)</td> 
   <td>根据字符数组的内容，来创建字符串对象</td> 
  </tr> 
  <tr> 
   <td>public String(byte[] chs)</td> 
   <td>根据字节数组的内容，来创建字符串对象</td> 
  </tr> 
 </tbody> 
</table>

**演示代码** :

public static void main(String[] args) {
        
    
        // 1.创建一个空白字符串对象(了解 几乎不用)
        String str1 = new String();
        System.out.println(str1);
    
        // 2.根据字符串内容创建对象(了解 几乎不用)
        String str2 = new String("你好 Java");
        System.out.println(str2); // 你好 Java
    
        // 3.根据字符数组, 创建字符串
        char[] charArr = {
        '你', '好', 'j', 'a', 'v', 'a'};
        String str3 = new String(charArr);
        System.out.println(str3); // 你好java
    
        // 4.根据字节数组, 创建字符串
        byte[] byteArr = {
        97, 98, 99, 100};
        String str4 = new String(byteArr);
        System.out.println(str4); // abcd
    }

**两种方式创建字符串有什么区别吗?**

*  以“”方式给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份。
    
     *  通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中。

#### String常用API ####

##### 1.字符串比较 #####

**字符串的内容比较不适合用“==”比较。**

*  为什么这么说呢, 我们来看下面这样一个案例, 定义一个用户名, 再让用户输入一个用户名, 比较是否相等

public static void main(String[] args) {
        
        // 1.定义的用户名
        String rightName = "chenyq";
    
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名");
        // 2.拿到用户输入的用户名
        String inputName = sc.next();
    
        // 3.判断用户名是否一致
        System.out.println(rightName == inputName); // false
    }

*  我们会发现, 即使用户输入"chenyq", 判断的值也是false, 这是因为 “==” 比较会去比较地址
 *  因此字符串的比较, 并不适合使用 “==” 比较

**字符串的内容比较**：

*  推荐使用String类提供的 equals 比较：只关心内容一样即可

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public boolean equals (Object anObject)</td> 
   <td align="left">将此字符串与指定对象进行比较。只关心字符内容是否一致！</td> 
  </tr> 
  <tr> 
   <td>public boolean equalsIgnoreCase (String anotherString)</td> 
   <td align="left">将此字符串与指定对象进行比较，忽略大小写比较字符串。只关心字符内容是否一致！</td> 
  </tr> 
 </tbody> 
</table>

**使用方法**:

*  `要比较的字符串.equals(被比较的字符串)`
 *  `要比较的字符串.equalsIgnoreCase(被比较的字符串)`

**演示代码** :

*  将上面例子中的判断, 修改为equals方法比较

System.out.println(rightName.equals(inputName));

*  如果我们想要忽略大小写, 那么可以使用equalsIgnoreCase方法比较

System.out.println(rightName.equalsIgnoreCase(inputName));

##### 2.其他常用API #####

**String的常用API如下** :

**获取字符串长度** :

*  方法 `public int length()` : 返回此字符串的长度
 *  **使用方法**: `str.length()`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 返回字符串的长度
        System.out.println(info.length()); // 10
    }

**根据索引返回字符** :

*  方法 `public char charAt(int index)` : 获取某个索引位置处的字符
 *  **使用方法**: `str.charAt(index)`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 获取某个索引处的字符
        System.out.println(info.charAt(4)); // o
    }

**将字符串转换成字符数组** :

*  方法 `public char[] toCharArray()` : 将当前字符串转换成字符数组返回
 *  **使用方法**: `str.toCharArray();`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 将字符串转换为字符数组返回
        char[] arr = info.toCharArray();
    }

**截取字符串** :

*  方法 `public String substring(int beginIndex, int endIndex)` : 根据开始和结束索引进行截取，得到新的字符串（包前不包后）
 *  **使用方法**: `str.substring(beginIndex, endIndex)`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 截取字符串, 例如: 截取索引1到8的字符串
        System.out.println(info.substring(1, 8)); // ello Ja
    }

*  方法 `public String substring(int beginIndex)` : 从传入的索引处截取，截取到末尾，得到新的字符串
 *  **使用方法**: `str.substring(index)`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 截取字符串, 从某一索引位置截取到尾部
        System.out.println(info.substring(4)); // o Java
    }

**替换字符串** :

*  方法 `public String replace(CharSequence target, CharSequence replacement)` : 使用新值，将字符串中的旧值替换，得到一个新的字符串
 *  **使用方法**: `str.replace(oldValue, newValue)`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 替换字符串中的某一字符
        System.out.println(info.replace('l', 'a')); // Heaao Java
        System.out.println(info.replace("Java", "JavaScript")); // Hello JavaScript      
    }

**分隔字符串返回数组** :

*  方法 `public String[] split(String regex)` : 根据传入的规则切割字符串，得到字符串数组返回
 *  **使用方法**: `str.split(regex)`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 按照传入规则, 将字符串切割, 放入一个字符串数组
        // 例如: 以空格分隔
        String[] arr = info.split(" ");
    }

**字符串是否包含…** :

*  方法 `public Boolean contains(CharSequence s)` : 判断字符串中是否包含某个值
 *  **使用方法**: `str.contains(value)`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 判断是否包含某个值
        System.out.println(info.contains("aaa")); // false
        System.out.println(info.contains("ll")); // true
    }

**判断是否以…开头**

*  方法 `public Boolean startsWith(String prefix)` : 判断字符串中是否以某个值开头
 *  **使用方法**: `str.startsWith(value)`

public static void main(String[] args) {
        
        String info = "Hello Java";
        // 判断字符串是否以某个值开始
        System.out.println(info.startsWith("Hello")); // true
        System.out.println(info.startsWith("hello")); // false
    }

### ArrayList ###

> ArrayList代表的是集合类，集合是一种容器，与数组类似，不同的是集合的大小是不固定的。
> 
> 通过创建ArrayList的对象表示得到一个集合容器，同时ArrayList提供了比数组更好用，更丰富的API (功能)给程序员使用

> **学习目标** :
> 
>  *  **ArrayList集合如何创建对象**: 要知道如何利用ArrayList创建对象代表集合容器来存放数据。
>  *  **ArrayList常用API**: 能够说出并使用ArrayList类提供的丰富的元素操作的功能：添加、获取、删除、修改等功能
>  *  **ArrayList存储自定义对象**: 能够使用ArrayList存储自定义的对象，并清楚ArrayList集合存储对象的底层原理
>  *  **ArrayList解决实际问题**: 能够使用ArrayList存储对象，并完成数据搜索，删除等常见业务需求

#### ArrayList集合 ####

**什么是集合?**

*  **集合是与数组类似，也是一种容器，用于装数据的**。

**数组的特点**:

*  数组定义完成并启动后，**类型确定、长度固定**。
 *  问题：在个数不能确定，且要进行增删数据操作的时候，数组是不太合适的。

**集合的特点**:

*  集合的**大小不固定**，启动后可以动态变化，类型也可以选择不固定。
 *  集合非常**适合做元素个数不确定**，且要**进行增删操作的业务场景**。
 *  集合的提供了许多丰富、好用的功能，而数组的功能很单一。

**ArrayList集合**

*  ArrayList是集合中的一种，它支持索引。 （暂时先学习这个，后续会讲解整个集合体系）

**ArrayList集合的对象获取**:

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public ArrayList()</td> 
   <td>创建一个空的集合对象</td> 
  </tr> 
 </tbody> 
</table>

*  使用方法: `ArrayList 名称 = new ArrayList`

public static void main(String[] args) {
        
        ArrayList list = new ArrayList();
    }

**ArrayList集合添加元素的方法**:

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public boolean add(E e)</td> 
   <td>将指定的元素追加到此集合的末尾</td> 
  </tr> 
  <tr> 
   <td>public void add(int index,E element)</td> 
   <td>在此集合中的指定位置插入指定的元素</td> 
  </tr> 
 </tbody> 
</table>

*  可以添加任意类型的数据

public static void main(String[] args) {
        
        ArrayList list = new ArrayList();
    
    		// 向集合添加不同类型的元素
        list.add("你好");
        list.add('你');
        list.add(123);
        list.add(false);
        list.add(18.0);
    
    		System.out.println(list); // [你好, 你, 123, false, 18.0]
    }

*  可以向指定位置插入指定元素

public static void main(String[] args) {
        
        ArrayList list = new ArrayList();
    
        list.add("你好");
        list.add('你');
        list.add(123);
        list.add(false);
        list.add(18.0);
    
        System.out.println(list); // [你好, 你, 123, false, 18.0]
    
    		// 向指定位置添加指定元素
        list.add(2, "aaaa");
        System.out.println(list); // [你好, 你, aaaa, 123, false, 18.0]
    }

**ArrayList对于泛型的支持**

*  `ArrayList<E>`：其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型。

**举例**：

*  `ArrayList<String>` ：此集合**只能操作字符串类型**的元素。
 *  `ArrayList<Integer>`：此集合**只能操作整数类型**的元素

public static void main(String[] args) {
        
        // ArrayList<String> list = new ArrayList<String>();
        // 泛型后面的类型声明可以不写
        ArrayList<String> list = new ArrayList();
    
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
    
        System.out.println(list); // [aaa, bbb, ccc]
    }

**注意：集合中只能存储引用类型，不支持基本数据类型。**

*  例如我们想要声明储存一系列整数, 我们需要声明为`ArrayList<Integer>`类型

public static void main(String[] args) {
        
        ArrayList<Integer> list = new ArrayList();
    
        list.add(111);
        list.add(222);
        list.add(333);
    
        System.out.println(list); // [111, 222, 333]
    }

#### ArrayList常用API ####

**根据索引返回元素** :

*  方法 `public E get(int index)` : 返回指定索引处的元素
 *  **使用方法**: `list.get(index)`

public static void main(String[] args) {
        
        ArrayList<Integer> list = new ArrayList();
    
        list.add(111);
        list.add(222);
        list.add(333);
    
        // 根据索引返回元素
        System.out.println(list.get(2)); // 333
    }

**返回集合的个数** :

*  方法 `public int size()` : 返回集合中的元素的个数
 *  **使用方法**: `list.size()`

public static void main(String[] args) {
        
        ArrayList<Integer> list = new ArrayList();
    
        list.add(111);
        list.add(222);
        list.add(333);
    
        // 返回集合中元素的个数
        System.out.println(list.size()); // 3
    }

**删除指定索引处元素** :

*  方法 `public E remove(int index)` : 删除指定索引处的元素，返回被删除的元素
 *  **使用方法**: `list.remove(index)`

public static void main(String[] args) {
        
        ArrayList<Integer> list = new ArrayList();
    
        list.add(111);
        list.add(222);
        list.add(333);
    
        // 删除指定索引处的元素, 返回被删除的元素
        System.out.println(list.remove(2)); // 333
    
        System.out.println(list); // [111, 222]
    }

**删除指定的元素** :

*  方法 `public boolean remove(Object o)` : 删除指定的元素，返回删除是否成功, 如果要删除的元素有多个, 只会删除第一个
 *  **使用方法**: `list.remove(Object)`

public static void main(String[] args) {
        
        ArrayList<String> list = new ArrayList();
    
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
    
        // 删除指定的元素, 返回删除是否成功
        System.out.println(list.remove("aaa")); // true
        System.out.println(list); // [bbb, ccc]
    }

**修改索引处的元素** :

*  方法 `public E set(int index,E element)` : 修改指定索引处的元素，返回被修改的元素
 *  **使用方法**: `list.set(index, element)`

public static void main(String[] args) {
        
        ArrayList<String> list = new ArrayList();
    
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
    
        // 修改指定索引处的元素, 返回被修改的元素
        System.out.println(list.set(1, "fff")); // bbb
        System.out.println(list); // [aaa, fff, ccc]
    }

#### 案例练习 ####

##### 遍历并删除元素值 #####

**需求**：

*  某个班级的考试在系统上进行，成绩大致为：98, 77, 66, 89, 79, 50, 100
 *  现在需要先把成绩低于80分以下的数据去掉。

**分析**：

*  定义ArrayList集合存储多名学员的成绩。
 *  遍历集合每个元素，如果元素值低于80分，去掉它。

**示例代码**:

public static void main(String[] args) {
        
        ArrayList<Integer> score = new ArrayList<>();
        
        score.add(98);
        score.add(77);
        score.add(66);
        score.add(89);
        score.add(79);
        score.add(50);
        score.add(100);
    
        for (int i = 0; i < score.size(); i++) {
        
            if (score.get(i) < 80) {
        
                score.remove(i);
                // 解决集合边删除, 边遍历的bug
                i -= 1;
            }
        }
    
        System.out.println(score);
    }

##### 学生信息系统的数据搜索 #####

**需求**:

*  后台程序需要存储学生信息并展示，然后要提供按照学号搜索学生信息的功能。

**分析**:

*  定义Student类，定义ArrayList集合存储如上学生对象信息，并遍历展示出来。
 *  提供一个方法，可以接收ArrayList集合，和要搜索的学号，返回搜索到的学生对象信息，并展示。
 *  使用死循环，让用户可以不停的搜索。

**示例代码**:

*  定义如下一个学生类

public class Student {
        
        private String studentId;
        private  String name;
        private int age;
        private  String classRoom;
    
        public Student() {
        
    
        }
    
        public Student(String studentId, String name, int age, String classRoom) {
        
            this.studentId = studentId;
            this.name = name;
            this.age = age;
            this.classRoom = classRoom;
        }
    
        public String getStudentId() {
        
            return studentId;
        }
    
        public void setStudentId(String studentId) {
        
            this.studentId = studentId;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public String getClassRoom() {
        
            return classRoom;
        }
    
        public void setClassRoom(String classRoom) {
        
            this.classRoom = classRoom;
        }
    }

*  具体实现代码

public class TestDemo01 {
        
        public static void main(String[] args) {
        
            ArrayList<Student> students = new ArrayList<>();
    
            students.add(new Student("20221314", "菠萝吹雪", 18, "软件一班"));
            students.add(new Student("20220315", "东方不败", 17, "网络一班"));
            students.add(new Student("20221816", "射雕英雄", 19, "信息一班"));
            students.add(new Student("20221918", "降龙八部", 20, "软件二班"));
    
            System.out.println("\t学号\t\t名称\t\t年龄\t班级");
            for (int i = 0; i < students.size(); i++) {
        
                Student stu = students.get(i);
                System.out.print(stu.getStudentId() + "\t");
                System.out.print(stu.getName() + "\t");
                System.out.print(stu.getAge() + "\t");
                System.out.println(stu.getClassRoom() + "\t");
            }
    
            Scanner sc = new Scanner(System.in);
            while (true) {
        
                System.out.println("请输入您要搜索的学号");
                String inputStuId = sc.next();
    
                Student stu = getStudentById(students, inputStuId);
                if (stu == null) {
        
                    System.out.println("查无此人");
                } else {
        
                    System.out.print(stu.getStudentId() + "\t");
                    System.out.print(stu.getName() + "\t");
                    System.out.print(stu.getAge() + "\t");
                    System.out.println(stu.getClassRoom() + "\t");
                }
            }
        }
    
        public static Student getStudentById(ArrayList<Student> students, String inputStuId) {
        
            for (int i = 0; i < students.size(); i++) {
        
                Student stu = students.get(i);
                if (stu.getStudentId().equals(inputStuId)) return stu;
            }
            return null;
        }
    }

[JavaAPI]: http://www.oracle.com/technetwork/java/javase/downloads/index.html