本文详细介绍了Java中String类的基本概念、创建方式、内存原理及常用API，包括字符串比较、遍历、替换、截取和分割等操作。同时，讲解了ArrayList集合的使用，包括构造器、泛型支持、常用方法和案例，如遍历、删除元素、存储自定义对象等。此外，还探讨了字符串与数组的区别以及集合的特点。
前言
- 该文章为Java自学笔记常用API（Sting、ArrayList）
- 学习视频为https://www.bilibili.com/video/av250694651
目录
API （Application Programming Interface,应用程序编程接口）
- Java写好的技术(功能代码)，咱们可以直接调用。
- Oracle 也为Java提供的这些功能代码提供了相应的 API文档(技术使用说明书) 。
下载API文档：
https://www.oracle.com/java/technologies/java-se-glance.html
在该网址内寻找对应JDK的API文档下载即可
1.String
String类概述
- java.lang.String 类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该字符串。
- Java 程序中的所有字符串文字（例如“abc”）都为此类的对象。
注意：String其实常被称为不可变字符串类型，它的对象在创建后不能被更改。
字符串对象存在哪里？
- 以“”方式给出的字符串对象，在字符串常量池中存储。
public static void main(String[] args) {
String name = "传智";
name += "教育";
name +="中心";
System.out.println(name);
}
String类型的变量无法修改，只是在内存中创建了新的对象（注意这里的新的对象在堆内存中，与字符串常量池的位置不同），然后让变量所存地址指向这一新的对象。原来的字符串对象都是没有改变的，所以称不可变字符串。
String类创建对象的2种方式
方式一：直接用" "定义。（推荐方式）
String name = "菜鹏";
方式二：通过String类的构造器创建对象。
| 构造器 | 说明 |
|---|---|
| public String() | 创建一个空白字符串对象，不含有任何内容 |
| public String(String original) | 根据传入的字符串内容，来创建字符串对象 |
| public String(char[] chs) | 根据字符数组的内容，来创建字符串对象 |
| public String(byte[] chs) | 根据字节数组的内容，来创建字符串对象 |
两者的区别：（面试常考）
- 以“”方式给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份。
- 通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中。
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true
char[] chs = {'a', 'b', 'c'};
String s3 = new String(chs);
String s4 = new String(chs);
System.out.println(s3 == s4); // false
内存原理
通过“ ”定义字符串内存原理：
public class Test {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);//true
}
}
通过new构造器得到字符串对象内存原理：
public class Test {
public static void main(String[] args) {
char[] chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = new String(chs);
System.out.println(s1 == s2);//false
}
}
String类常见面试题
问题：下列代码的运行结果是？
public class Test2 {
public static void main(String[] args) {
String s2 = new String("abc");//1
String s1 = "abc"; //2
System.out.println(s1 == s2);
}
}
第一行代码创建了两个对象，第一个对象"abc"放在了常量池中，然后通过构造器new了第二个对象放在了堆内存中。
第二行代码没有创建对象，0个，因为第一行代码已经创建了"abc"放入了常量池中，如果没有第一行代码是创建了1个。
运行结果为false，s1存储的地址是常量"abc"的地址，s2存储的地址是创建的String对象的地址
public class Test3 {
public static void main(String[] args) {
String s1 = "abc"; //1
String s2 = "ab"; //2
String s3 = s2 + "c";//3
System.out.println(s1 == s3);
}
}
第一行与第二行代码创建了两个对象放在了字符串常量池中。
第三行代码因为等号右边涉及了变量s2与"c"的运算，所以创建的对象放在堆内存中。
因此结果为false。（注意，只有由双引号直接给出的字符串才会被放入字符串常量池）
public class Test4 {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "a" + "b" + "c";
System.out.println(s1 == s2);
}
}
结果为true。且s2不会创建新对象，这里与前文有不同，原因在于Java存在编译优化机制，程序在编译时： “a” + “b” + “c” 会直接转成 “abc”，在程序编译为字节码文件后，第二行代码会变为String s2 = “abc”;
String类常用API-字符串内容比较
public class StringDemoAPI3 {
public static void main(String[] args) {
String sysLoginName = "abcdefg";
Scanner sc = new Scanner(System.in);
System.out.println("请您输入您的登录名称");
String loginName = sc.next();
System.out.println(sysLoginName == loginName); //false
}
}
结论：字符串的内容比较不适合用“==”比较。
这是因为在Java中，String类型的变量存储的是字符串在内存中的地址，因此即使内容相同，但存储地址还是可以不同。因此在比较字符串内容时，需要采用其他方法。
字符串的内容比较：
- 推荐使用String类提供的“equals”比较：只关心内容一样即可
| 方法名 | 说明 |
|---|---|
| public boolean equals (Object anObject) | 将此字符串与指定对象进行比较。只关心字符内容是否一致！ |
| public boolean equalsIgnoreCase (String anotherString) | 将此字符串与指定对象进行比较，忽略大小写比较字符串。只关心字符内容是否一致！ |
但在开发中也有使用==比较内容的时候，那就是在比较基本数据类型时。
String类常用API-遍历、替换、截取、分割操作
| 方法名 | 说明 |
|---|---|
| public int length() | 返回此字符串长度 |
| public char charAt(int index) | 获取某个索引位置处的字符 |
| public char[] toCharArray() | 将当前字符串转换成字符数组返回 |
| public String substring(int beginIndex, int endIndex) | 根据开始和结束索引进行截取，得到新的字符串（包钱不包后） |
| public String substring(int beginIndex) | 从传入的索引处截取，截取到末尾，得到新的字符串 |
| public String replace(CharSequence target, CharSequence replacement) | 使用新值，将字符串中的旧值替换，得到新的字符串 |
| public String[] split(String regex) | 根据传入的规则切割字符串，得到字符串数组返回 |
实例：
public class StringAPI {
public static void main(String[] args) {
// 1、public int length(): 获取字符串的长度
String name = "我好菜啊abc";
System.out.println(name.length());
// 2、public char charAt(int index): 获取某个索引位置处的字符
char c = name.charAt(1);
System.out.println(c);
System.out.println("------------遍历字符串中的每个字符-------------");
for (int i = 0; i < name.length(); i++) {
char ch = name.charAt(i);
System.out.println(ch);
}
// 3、public char[] toCharArray()：: 把字符串转换成字符数组
char[] chars = name.toCharArray();
for (int i = 0; i < chars.length; i++) {
char ch = chars[i];
System.out.println(ch);
}
// 4、public String substring(int beginIndex, int endIndex) ：截取内容，(包前不包后的)
String name2 = "Java是最厉害的编程语言！";
// 01234567 89
String rs = name2.substring(0, 9);
System.out.println(rs);
String rs1 = name2.substring(4, 9);
System.out.println(rs1);
// 5、public String substring(int beginIndex):从当前索引一直截取到末尾
String rs2 = name2.substring(4);
System.out.println(rs2);
// 6、public String replace(CharSequence target, CharSequence replacement)
String name3 = "我好菜啊。。我是一个菜比，纯纯的菜比。";
String rs3 = name3.replace("菜比", "***");
System.out.println(rs3);
// 7、public boolean contains(CharSequence s)
System.out.println(name3.contains("菜比")); // true
System.out.println(name3.contains("菜比")); // false
// 8、public boolean startsWith(String prefix)
System.out.println(name3.startsWith("我"));
System.out.println(name3.startsWith("我好菜啊"));
System.out.println(name3.startsWith("我好牛"));
// 9、public String[] split(String s): 按照某个内容把字符串分割成字符串数组返回。
String name4 = "金毛,哈士奇,柯基";
String[] names = name4.split(",");
for (int i = 0; i < names.length; i++) {
System.out.println("选择了：" + names[i]);
}
}
}
String类案例实战
验证码
public static void main(String[] args) {
String datas = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
// 循环5次，每次生成一个随机的索引，提取对应的字符连接起来即可
String code = "";
Random r = new Random();
for (int i = 0; i < 5; i++) {
int index = r.nextInt(datas.length());
char c = datas.charAt(index);
code += c;
}
System.out.println(code);
}
模拟用户登录
public class UserLogin {
public static void main(String[] args) {
// 1、定义正确的登录名称和密码
String okLoginName = "admin";
String okPassword = "caicai";
// 2、定义一个循环，循环3次，让用户登录
Scanner sc = new Scanner(System.in);
for (int i = 1; i <= 3; i++) {
System.out.println("请您输入登录名称：");
String loginName = sc.next();
System.out.println("请您输入登录密码：");
String password = sc.next();
// 3、判断登录是否成功！
if (okLoginName.equals(loginName)) {
// 4、判断密码是否正确
if (okPassword.equals(password)) {
System.out.println("登录成功！");
break;
} else {
// 密码错误了
System.out.println("您的密码不正确！您还剩余" + (3 - i) + "次机会登录！");
}
} else {
System.out.println("您的登录名称不正确！您还剩余" + (3 - i) + "次机会登录！");
}
}
}
}
屏蔽手机号码
public class number {
public static void main(String[] args) {
// 1、键盘录入一个手机号码
Scanner sc = new Scanner(System.in);
System.out.println("请您输入您的手机号码：");
String tel = sc.next();
// 2、截取号码的前三位，后四位
String before = tel.substring(0, 3); // 0 1 2
String after = tel.substring(7); // 从索引7开始截取到手机号码的末尾
String s = before + "****" + after;
System.out.println(s);
}
}
2.ArrayList
集合概述
集合与数组类似，也是一种容器，用于装数据。
数组的特点：
数组定义完成并启动后，类型确定、长度固定。
问题：在个数不能确定，且要进行增删数据操作的时候，数组是不太合适的。
集合的特点：
集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。
集合非常适合做元素个数不确定，且要进行增删操作的业务场景。
集合还提供了许多丰富、好用的功能，而数组的功能很单一。
ArrayList集合快速入门
ArrayList是集合中的一种，它支持索引。 （暂时先学习这个，后期会学习整个集合体系）
ArrayList集合的对象获取:
| 构造器 | 说明 |
|---|---|
| public ArrayList() | 创建一个新的集合对象 |
ArrayList list = new ArrayList();
ArrayList集合添加元素的方法：
| 方法名 | 说明 |
|---|---|
| public boolean add(E e) | 将指定的元素追加到此集合的末尾 |
| public void add(int index,E element) | 将此集合中的指定位置插入指定的元素 |
实例：
public class ArrayListDemo1 {
public static void main(String[] args) {
ArrayList List = new ArrayList();
List.add("Java");
List.add("Java");
List.add("MySQL");
List.add("菜鹏");
List.add(666);
List.add('\t');
List.add(666);
List.add(13.14);
List.add(0,"Python");
System.out.println(List);
}
}
注意：这里的输出结果是集合内部的内容，不是地址，但List本质存储的还是地址，输出的原因与后面要学的继承有关。
ArrayList对泛型的支持
泛型概述:
- ArrayList：其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型。
举例：
- ArrayList< String> ：此集合只能操作字符串类型的元素。ArrayList< Object> list1 = new ArrayList();
- ArrayList< Integer>：此集合只能操作整数类型的元素。
注意：集合中只能存储引用类型，不支持基本数据类型。
ArrayList常用API、遍历
ArrayList集合常用方法：
| 方法名称 | 说明 |
|---|---|
| public E get(int index) | 返回指定索引处的元素 |
| public int size() | 返回集合中元素的个数 |
| public E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| public boolean remove(Object o) | 删除指定的元素，返回删除是否成功 |
| public E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
实例：
public class ArrayListDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Java");
list.add("MySQL");
list.add("MyBatis");
list.add("HTML");
// 1、public E get(int index)：获取某个索引位置处的元素值
String e = list.get(3);
System.out.println(e);
// 2、public int size()：获取集合的大小（元素个数）
System.out.println(list.size());
// 3、完成集合的遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
// 4、public E remove(int index)：删除某个索引位置处的元素值,并返回被删除的元素值
System.out.println(list); // [Java, Java, MySQL, MyBatis, HTML]
String e2 = list.remove(2);
System.out.println(e2);
System.out.println(list);
// 5、public boolean remove(Object o):直接删除元素值，删除成功返回true，删除失败返回false
System.out.println(list.remove("MyBatis"));
System.out.println(list);
ArrayList<String> list1 = new ArrayList<>();
list1.add("Java");
list1.add("王宝强");
list1.add("Java");
list1.add("MySQL");
System.out.println(list1);
// 只会删除第一次出现的这个元素值，后面的不删除
System.out.println(list1.remove("Java"));
System.out.println(list1);
// 6、public E set(int index,E element)：修改某个索引位置处的元素值。
String e3 = list1.set(0 , "贾乃亮");
System.out.println(e3);
System.out.println(list1);
}
}
ArrayList集合案例：遍历并删除元素
public static void main(String[] args) {
// 1、创建集合对象：存入学生成绩(98,77,66,89,79,50,100)
ArrayList<Integer> scores = new ArrayList<>();
scores.add(98);
scores.add(77);
scores.add(66);
scores.add(89);
scores.add(79);
scores.add(50);
scores.add(100);
System.out.println(scores);
//遍历集合中的每个元素
//方法1
// for (int i = 0; i < scores.size(); i++) {
// int score = scores.get(i);
// // 2、判断这个分数是否低于80分，如果低于则从集合中删除它
// if(score < 80){
// scores.remove(i);
// }
// }
// System.out.println(scores);//[98, 66, 89, 50, 100]结果错误
//方法2
for (int i = scores.size() - 1; i >= 0 ; i--) {
int score = scores.get(i);
if(score < 80){
scores.remove(i);
}
}
System.out.println(scores);//[98, 89, 100]正确
}
方法1错误的原因在于集合与数组不同，当集合删除一个元素后，后面的元素会自动补上被删元素的位置，以至于遍历时会跳过部分元素。
方法2从后往前遍历则解决了这一问题，被删元素的后续元素补位不影响继续遍历前面的元素。
ArrayList集合案例：存储自定义类型的对象
//Movie类省略
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList<Movie> movies = new ArrayList<>();
movies.add(new Movie("《肖生克的救赎》", 9.7 , "罗宾斯"));//也可以先创建对象，再将对象add进集合中
movies.add(new Movie("《霸王别姬》", 9.6 , "张国荣、张丰毅"));
movies.add(new Movie("《阿甘正传》", 9.5 , "汤姆.汉克斯"));
System.out.println(movies);
for (int i = 0; i < movies.size(); i++) {
Movie movie = movies.get(i);
System.out.println("片名：" + movie.getName());
System.out.println("评分：" + movie.getScore());
System.out.println("主演：" + movie.getActor());
}
}
}
内存原理
结论：集合中存储的元素并不是对象本身，而是对象的地址。
ArrayList集合案例：元素搜索
public class ArrayListTest6 {
public static void main(String[] args) {
// 1、定义一个学生类，后期用于创建对象封装学生数据
// 2、定义一个集合对象用于装学生对象
ArrayList<Student> students = new ArrayList<>();
students.add(new Student("20180302", "叶孤城", 23, "护理一班"));
students.add(new Student("20180303", "东方不败", 23, "推拿二班"));
students.add(new Student("20180304", "西门吹雪", 26, "中药学四班"));
students.add(new Student("20180305", "梅超风", 26, "神经科2班"));
System.out.println("学号\t\t名称\t年龄\t\t班级");
// 3、遍历集合中的每个学生对象并展示其数据
for (int i = 0; i < students.size(); i++) {
Student s = students.get(i);
System.out.println(s.getStudyId() + "\t\t" + s.getName() + "\t\t"
+ s.getAge() + "\t\t" + s.getClassName());
}
// 4、让用户不断的输入学号，可以搜索出该学生对象信息并展示出来（独立成方法）
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请您输入要查询的学生的学号：");
String id = sc.next();
Student s = getStudentByStudyId(students, id);
// 判断学号是否存在
if (s == null) {
System.out.println("查无此人！");
} else {
// 找到了该学生对象了，信息如下
System.out.println(s.getStudyId() + "\t\t" + s.getName() + "\t\t"
+ s.getAge() + "\t\t" + s.getClassName());
}
}
}
private static Student getStudentByStudyId(ArrayList<Student> students, String id) {
for (int i = 0; i < students.size(); i++) {
Student s = students.get(i);
if(s.getStudyId().equals(id)){
return s;
}
}
return null; // 查无此学号！
}
}
常用API（String、Array List）部分完结
扫一扫
998
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
