一、String类的常用方法
1. String类概述
String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在java.lang 包下，所以使用的时候不需要导包！
2. String类的构造方法
- 常用的构造方法
public String() 创建一个空字符串对象 例如: ""
public String(byte[] bytes) 根据byte数组中的内容,来创建对应的字符串对象
public String(byte[] bytes, int offset, int length) 指定byte数组的范围,根据指定范围中的内容,来创建对应的字符串对象
public String(char[] value) 根据char数组中的内容,来创建对应的字符串对象
直接写字符串字面值也是String类对象 例如: String str = "abc"; 常用
- 使用String类的构造方法
public class StringDemo01 {
public static void main(String[] args) {
//public String()：创建一个空白字符串对象，不含有任何内容
String s1 = new String();
System.out.println("s1:" + s1);
//public String(char[] chs)：根据字符数组的内容，来创建字符串对象
char[] chs = {'a', 'b', 'c'};
String s2 = new String(chs);
System.out.println("s2:" + s2);
//public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
byte[] bys = {97, 98, 99};
String s3 = new String(bys);
System.out.println("s3:" + s3);
//String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
String s4 = "abc";
System.out.println("s4:" + s4);
}
}
3. 创建字符串对象两种方式的区别
通过构造方法创建
- 通过
new创建的字符串对象，每一次new都会申请一个内存空间，虽然字符串内容相同，但是地址值不同
char[] chs = {'a','b','c'};
String s1 = new String(chs);// s1字符串的内容: abc
String s2 = new String(chs);// s2字符串的内容: abc
// 上面的代码中,JVM首先会先创建一个字符数组,然后每一次new的时候都会有一个新的地址,只不过s1和s2参考的字符串内容是相同的
直接赋值方式创建
- 以
“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护。
String s3 = "abc";
String s4 = "abc";
// 上面的代码中,针对第一行代码,JVM会建立一个String对象放在字符串池中,并给s3参考;第二行代码,则让s4直接参考字符串池中String对象,也就是说他们本质上是同一个对象
- 内存详解
public class Test {
public static void main(String[] args) {
/*
创建字符串对象两种方式的区别:
- 通过构造方法创建: 通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然字符串内容相同，但是地址值不同
- 直接赋值方式创建: 以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护
*/
char[] chs = {'a','b','c'};
String str1 = new String(chs);
String str2 = new String(chs);
System.out.println("str1:"+str1);// str1: abc 打印的是字符串内容
System.out.println("str2:"+str2);// str2: abc 打印的是字符串内容
System.out.println(str1 == str2);// false == 引用数据类型比较的是地址值
System.out.println("=========================");
String str3 = "abc";
String str4 = "abc";
System.out.println(str3 == str4);// true
}
}
4. String类的特点
- String类的字符串不可变，它们的值在创建后不能被更改
String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd","d",3个对象，s1从指向"abc"，改变指向，指向了"abcd"。
- 虽然 String 的值是不可变的，但是它们可以被共享
String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。
- 字符串效果上相当于字符数组( char[] )
//例如：
String str = "abc";
相当于：
char[] data = {'a', 'b', 'c'};
String str = new String(data);
// String底层是靠字符数组实现的,jdk9底层是字节数组。
byte[] bys = {97,98,99};
String str = new String(bys);
5. 字符串的比较
==号比较
- 比较基本数据类型：比较的是具体的值
int num1 = 10;
int num2 = 20;
int num2 = 10;
num1 == num2 ===> 10==20 结果:false
num1 == num3 ===> 10==10 结果：true
- 比较引用数据类型：比较的是对象地址值
String str1 = new String("abc");
String str2 = new String("abc");
str1 == str2 ===> str1存储的对象地址值 == str2存储的对象地址值 结果: false
equals比较
-
字符串是对象,它比较内容是否相同,是通过一个方法来实现的,就是equals()方法
-
方法介绍
public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写 -
示例代码
public class StringDemo02 {
public static void main(String[] args) {
//构造方法的方式得到对象
char[] chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = new String(chs);
//直接赋值的方式得到对象
String s3 = "abc";
String s4 = "abc";
//比较字符串内容是否相同
System.out.println(s1.equals(s2));// true
System.out.println(s1.equals(s3));// true
System.out.println(s3.equals(s4));// true
}
}
equalsIgnoreCase比较字符串
- public boolean equalsIgnoreCase (String anotherString)` ：将此字符串与指定对象进行比较，忽略大小写。
- 示例代码
public static void main(String[] args) {
// public boolean equalsIgnoreCase (String anotherString)
// 1.创建一个字符串对象
String str1 = "hello";
// 2.创建一个字符串对象
String str2 = "Hello";
// 3.使用equalsIgnoreCase()方法比较str1和str2字符串是否相等
boolean res1 = str1.equalsIgnoreCase(str2);
System.out.println("res1的值是:"+res1);// true
}
6. String类获取功能的方法
-
public int length ()：返回此字符串的长度。 -
public String concat (String str)：将指定的字符串连接到该字符串的末尾。 -
public char charAt (int index)：返回指定索引处的 char值。 -
public int indexOf (String str)：返回指定子字符串第一次出现在该字符串内的索引。 -
public String substring (int beginIndex)：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。 -
public String substring (int beginIndex, int endIndex)：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。 -
示例代码
public class Test {
public static void main(String[] args) {
/*
String类获取功能的方法:
- public int length () ：返回此字符串的长度。
- public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
- public char charAt (int index) ：返回指定索引处的 char值。
- public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
- public int indexOf(String str, int fromIndex)
- public int lastIndexOf(String str) 返回指定子字符串最后一次出现在该字符串内的索引。
- public int lastIndexOf(String str, int fromIndex)
- public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
- public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
*/
String str = "hello-world世界,你好";
// public int length () ：返回此字符串的长度。
int len = str.length();
System.out.println("str字符串的长度:"+len);// 16
// public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
String newStr = str.concat("中国你好");
System.out.println("拼接后的字符串:"+newStr);// hello-world世界,你好中国你好
System.out.println("str:"+str);// hello-world世界,你好
// public char charAt (int index) ：返回指定索引处的 char值。
// 获取1索引位置上的元素
char c = str.charAt(1);
System.out.println(c);// e
// 遍历字符串中的每一个字符串
/*for (int i = 0;i<len;i++){
System.out.println(str.charAt(i));
}*/
// public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
// 获取l字符串第一次出现的索引
int index1 = str.indexOf("l");
System.out.println("index1:"+index1);// 2
// public int indexOf(String str, int fromIndex)
// 获取l字符串第二次出现的索引
int index2 = str.indexOf("l", index1+1);
System.out.println("index2:"+index2);// 3
// 获取l字符串第三次出现的索引
int index3 = str.indexOf("l", index2 + 1);
System.out.println("index3:"+index3);// 9
// public int lastIndexOf(String str) 返回指定子字符串最后一次出现在该字符串内的索引。
// 获取l字符串最后一次出现的索引
int index = str.lastIndexOf("l");
System.out.println("index:"+index);// 9
// public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
String subStr1 = str.substring(2);
System.out.println("subStr1:"+subStr1);// llo-world世界,你好
// public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
// 截取world子字符串
String subStr2 = str.substring(6, 11);
System.out.println("subStr2:"+subStr2);// world
}
}
二、StringBuilder类
1.StringBuilder类概述以及与String类的区别
StringBuilder类概述
StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的。
StringBuilder类和String类的区别
-
String类：内容是不可变的
-
StringBuilder类：内容是可变的
2. StringBuilder类的构造方法
- 常用的构造方法
public StringBuilder()创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象
- 示例代码
public class StringBuilderDemo01 {
public static void main(String[] args) {
//public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
StringBuilder sb = new StringBuilder();
System.out.println("sb:" + sb);
System.out.println("sb.length():" + sb.length());
//public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
StringBuilder sb2 = new StringBuilder("hello");
System.out.println("sb2:" + sb2);
System.out.println("sb2.length():" + sb2.length());
}
}
2. StringBuilder类拼接和反转方法
- 添加和反转方法
public StringBuilder append(任意类型) 拼接数据，并返回对象本身
public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身
public StringBuilder reverse() 反转字符串,并返回对象本身
- 示例代码
public class StringBuilderDemo01 {
public static void main(String[] args) {
//创建对象
StringBuilder sb = new StringBuilder();
//链式编程
sb.append("hello").append("world").append("java").append(100);
System.out.println("sb:" + sb);
//public StringBuilder reverse()：返回相反的字符序列
sb.reverse();
System.out.println("sb:" + sb);
}
}
4. StringBuilder和String相互转换
-
StringBuilder转换为String。
public String toString()：通过StringBuilder类中的 toString() 就可以实现把 StringBuilder 转换为 String。 -
String转换为StringBuilder
public StringBuilder(String s)：通过StringBuilder的构造方法就可以实现把 String 转换为 StringBuilder -
实例代码
public class StringBuilderDemo02 {
public static void main(String[] args) {
/*
//StringBuilder 转换为 String
StringBuilder sb = new StringBuilder();
sb.append("hello");
//String s = sb; //这个是错误的做法
//public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
String s = sb.toString();
System.out.println(s);
*/
//String 转换为 StringBuilder
String s = "hello";
//StringBuilder sb = s; //这个是错误的做法
//public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);
}
}
三、 ArrayList
1. 集合的概述以及与数组的区别
-
什么是集合
- 集合其实就是一个大小可变的容器,可以用来存储多个数据
- 集合的特点: 集合的大小可以动态改变,可以存储各种类型的数据
-
集合与数组的区别
- 数组：数组大小固定，只能存储相同数据类型的数据
- 集合：集合大小可动态扩展，可以存储各种引用类型的数据
2. ArrayList类概述
通过查看ArrayList类的API:
java.util.ArrayList <E>：该类需要 import导入使后使用。- 表示一种指定的数据类型,叫做泛型,用于约束集合中存储元素的数据类型
- 怎么用呢?
- 在出现E的地方我们使用引用数据类型替换即可，表示我们将存储哪种引用类型的元素。
- 例如:
- ArrayList 表示ArrayList集合中只能存储String类型的对象
- ArrayList 表示ArrayList集合中只能存储Student类型的对象
- …
- 概述:
- ArrayList类底层是大小可变的数组的实现，存储在内的数据称为元素。也就是说ArrayList 中可以不断添加元素，其大小会自动增长。
3. ArrayList类构造方法
- ArrayList的构造方法
ArrayList()构造一个初始容量为 10 的空列表。 - 实例代码
public class Test {
public static void main(String[] args) {
/*
ArrayList类构造方法:
ArrayList() 构造一个初始容量为 10 的空列表。
如果一个集合需要存储基本数据类型的数据,那么需要把基本数据类型转换为对应的引用数据类型
基本数据类型 引用数据类型
byte Byte
short Short
int Integer
long Long
double Double
float Float
char Character
boolean Boolean
*/
// 创建了一个ArrayList集合对象,限制集合中的元素类型为String类型
ArrayList<String> list1 = new ArrayList<String>();
// 创建一个ArrayList集合对象,限制集合中的元素类型为student类型
ArrayList<Student> list2 = new ArrayList<Student>();
// 简写:
ArrayList<String> list11 = new ArrayList<>();
ArrayList<Student> list22 = new ArrayList<>();
// 创建一个ArrayList集合对象,可以存储任意引用类型的数据
ArrayList list3 = new ArrayList();
// 把基本数据类型转换为对应的引用数据类型
Integer i = 10;// 基本数据类型转换为引用数据类型
int num = i;// 引用数据类型转换为基本数据类型
// 创建一个ArrayList集合对象,限制集合中的元素类型为Integer类型
ArrayList<Integer> list4 = new ArrayList<>();
}
}
4. ArrayList类添加元素方法
-
ArrayList添加元素的方法
- public boolean add(E e)：将指定的元素追加到此集合的末尾
- public void add(int index,E element)：在此集合中的指定位置插入指定的元素
-
实例代码
public class Test {
public static void main(String[] args) {
/*
ArrayList类添加元素方法:
boolean add(E e) 将指定的元素添加在集合的末尾
void add(int index, E element) 将指定的元素插入在指定的索引位置。
*/
// 创建了一个ArrayList集合对象,限制集合中的元素类型为String类型
ArrayList<String> list1 = new ArrayList<>();
// 往list1集合的末尾添加元素
list1.add("张三");
list1.add("李四");
list1.add("王二");
// 打印集合
System.out.println(list1);// [张三, 李四, 王二]
// 往list1集合所有为1的位置添加一个麻子元素
list1.add(1, "麻子");
System.out.println(list1);// [张三, 麻子, 李四, 王二]
System.out.println("======================================");
// 创建一个ArrayList集合对象,可以存储任意引用类型的数据
ArrayList list3 = new ArrayList();
// 往list3集合中添加任意引用数据类型的元素
list3.add("李华");
list3.add(18);// int---->自动转换为Integer类型
list3.add(3.14);// double--->自动转换为Double类型
System.out.println(list3);// [李华, 18, 3.14]
System.out.println("==========================");
// 创建一个ArrayList集合对象,限制集合中的元素类型为Integer类型
ArrayList<Integer> list4 = new ArrayList<>();
// 往list4集合中添加任意引用数据类型的元素
list4.add(10);
list4.add(20);
list4.add(30);
System.out.println(list4);// [10, 20, 30]
}
}
5. ArrayList类常用方法
- ArrayList常用方法
public boolean remove(Object o) 删除指定的元素，返回删除是否成功
public E remove(int index) 删除指定索引处的元素，返回被删除的元素
public E set(int index, E element) 修改指定索引处的元素，返回被修改的元素
public E get(int index) 返回指定索引处的元素
public int size() 返回集合中的元素的个数
6. ArrayList存储字符串并遍历
- 实现
import java.util.ArrayList;
/*
ArrayList存储字符串并遍历
需求
- 创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合
分析:
1.创建ArrayList集合对象,限制集合中元素的类型为String类型
2.往集合对象中存储3个字符串元素 使用add()方法往集合中添加元素
3.获取集合中元素的个数
4.循环遍历集合中每一个元素
*/
public class Test1ArrayList {
public static void main(String[] args) {
// 1.创建ArrayList集合对象,限制集合中元素的类型为String类型
ArrayList<String> list = new ArrayList<>();
// 2.往集合对象中存储3个字符串元素 使用add()方法往集合中添加元素
list.add("张三");
list.add("李四");
list.add("王五");
// 3.获取集合中元素的个数
//int size = list.size();
// 4.循环遍历集合中每一个元素
for (int i = 0;i<list.size();i++){
// 获取元素,并打印
System.out.println(list.get(i));
}
}
}
7. ArrayList存储学生对象并遍历
- 实现
/*
思路：
1:定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
2:创建集合对象
3:键盘录入学生对象所需要的数据
4:创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
5:往集合中添加学生对象
6:遍历集合，采用通用遍历格式实现
*/
public class ArrayListTest {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> array = new ArrayList<Student>();
//为了提高代码的复用性，我们用方法来改进程序
addStudent(array);
addStudent(array);
addStudent(array);
//遍历集合，采用通用遍历格式实现
for (int i = 0; i < array.size(); i++) {
Student s = array.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
}
/*
两个明确：
返回值类型：void
参数：ArrayList<Student> array
*/
public static void addStudent(ArrayList<Student> array) {
//键盘录入学生对象所需要的数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生姓名:");
String name = sc.nextLine();
System.out.println("请输入学生年龄:");
String age = sc.nextLine();
//创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
Student s = new Student();
s.setName(name);
s.setAge(age);
//往集合中添加学生对象
array.add(s);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
