20_字符串和集合
1、字符串类型
字符串是对于程序员而言非常重要的载体，稳定、兼顾、数据容量大……
1.1 字符串存储
/*
* 字符串存储和比较
*/
public class Demo1 {
public static void main(String[] args) {
String str1 = "今天起雾了";
String str2 = "今天起雾了";
String str3 = new String("今天起雾了");
String str4 = new String(str1);
/*
* == 对与引用数据类型而言 比较的是引用数据类型存储的数据地址
* 比较的是字符串数据的存储地址
*/
System.out.println("str1 == str2:" + (str1 == str2)); //T
System.out.println("str1 == str3:" + (str1 == str3)); //F
System.out.println("str2 == str3:" + (str2 == str3)); //F
System.out.println("str1 == str4:" + (str1 == str4)); //F
System.out.println("---------------------------");
/*
* 比较的是字符串数据的内容
*/
System.out.println("str1.equal(str2):" + str1.equals(str2)); //T
System.out.println("str1.equal(str3):" + str1.equals(str3)); //T
System.out.println("str2.equal(str3):" + str2.equals(str3)); //T
System.out.println("str1.equal(str4):" + str1.equals(str4)); //T
}
}
1.2 字符串操作相关方法
1.2.1 字符串获取方法
1、 int length();
返回字符串有效字符个数
2、char charAt(int index);
返回字符串指定下标位置 index 对应的的字符数据
3、int indexOf(int ch);
参数可以传递 字符 或者 字符的编码值
查询指定字符在当前字符串中第一次出现的下标位置 如果没有返回 -1
4、int lastIndexOf(int ch);
查询指定字符在当前字符串中最后一次出现的下标位置 如果没有返回 -1
5、int indexOf(String str);
查询指定字符串在当前字符串中第一次出现的下标位置 如果没有返回 -1
查询到返回的位置是指定字符串的第一个字符在当前字符串中的下标位置
6、int lastIndexOf(String str);
查询指定字符串在当前字符串中最后一次出现的下标位置 如果没有返回 -1
查询到返回的位置是指定字符串的第一个字符在当前字符串中的下标位置
/*
* 字符串相关操作方法
*/
public class Demo2 {
public static void main(String[] args) {
String str = "abcdefgfedcbabcdefg";
/*
* int length();
* 返回字符串有效字符个数
*/
System.out.println("length:" + str.length());
System.out.println("---------------------");
/*
* char charAt(int index);
* 返回字符串指定下标位置 index 对应的的字符数据
*/
for (int i =0; i < str.length(); i++) {
System.out.println(str.charAt(i));
}
System.out.println("---------------------");
/*
* int indexOf(int ch);
* 参数可以传递 字符 或者 字符的编码值
* 查询指定字符在当前字符串中第一次出现的下标位置 如果没有返回 -1
*
*/
System.out.println("字符 a 第一次出现的下标位置：" + str.indexOf('a'));
System.out.println("字符 a 第一次出现的下标位置：" + str.indexOf(97));
System.out.println("字符 A 第一次出现的下标位置：" + str.indexOf('A'));
System.out.println("字符 A 第一次出现的下标位置：" + str.indexOf(65));
System.out.println("---------------------");
/*
* int lastIndexOf(int ch);
* 查询指定字符在当前字符串中最后一次出现的下标位置 如果没有返回 -1
*/
System.out.println("字符 a 最后一次出现的下标位置：" + str.lastIndexOf('a'));
System.out.println("字符 a 最后一次出现的下标位置：" + str.lastIndexOf(97));
System.out.println("字符 A 最后一次出现的下标位置：" + str.lastIndexOf('A'));
System.out.println("字符 A 最后一次出现的下标位置：" + str.lastIndexOf(65));
System.out.println("---------------------");
/*
* int indexOf(String str);
* 查询指定字符串在当前字符串中第一次出现的下标位置 如果没有返回 -1
* 查询到返回的位置是指定字符串的第一个字符在当前字符串中的下标位置
*/
System.out.println("字符串 abc 第一次出现的下标位置：" + str.indexOf("abc"));
System.out.println("---------------------");
/*
* int lastIndexOf(String str);
* 查询指定字符串在当前字符串中最后一次出现的下标位置 如果没有返回 -1
*/
System.out.println("字符串 abc 最后一次出现的下标位置：" + str.lastIndexOf("abc"));
}
}
1.2.2 字符串判断方法
1、boolean endsWith(String str);
判断当前调用方法字符串是否以参数字符串结尾
2、boolean startsWith(String str);
判断当前调用方法字符串是否以参数字符串开头
3、boolean isEmpty();
判断字符串是否为空，JDK1.6 之后版本空字符串为 ""
4、boolean contains(String str);
判断当前调用方法字符串是否包含参数目标字符串
5、boolean equals(Object obj) // Override equals
method in Object 重写 Object 方法
判断当前调用方法字符串和参数字符串是否内容一致
6、boolean equalsIgnoreCase(String str);
判断当前调用方法字符串和参数字符串，不区分大小写比较字符串内容
【注意】
Java 中的空字符串 ""
任何数据类型 + "" 都可以变成字符串类型
public class Demo3 {
public static void main(String[] args) {
String str1 = "abcdefgfedcba";
String str2 = "";
/*
* boolean endsWith(String str);
* 判断当前方法调用字符串是否以 字符str 结尾
*/
System.out.println("endsWith:" + str1.endsWith("ba"));
System.out.println("endsWith:" + str1.endsWith("hi"));
System.out.println("-----------------");
/*
* boolean startsWith(String str);
* 判断当前方法调用字符串是否以 字符str 开头
*/
System.out.println("startsWith:" + str1.startsWith("ab"));
System.out.println("startsWith:" + str1.startsWith("hi"));
System.out.println("-----------------");
/*
* boolean isEmpty();
* 判断字符串是否为空
* JDK 1.6之后的版本空字符串为 ""
*/
System.out.println("isEmpty:" + str1.isEmpty());
System.out.println("isEmpty:" + str2.isEmpty());
System.out.println("-----------------");
/*
* boolean contains(String str);
* 判断当前调用方法字符串是否包含参数 str
*/
System.out.println("contains:" + str1.contains("fg"));
System.out.println("contains:" + str1.contains("hi"));
System.out.println("-----------------");
/*
* boolean equals(Object obj);
* 判断当前调用方法字符串和参数字符串是否内容一致
*
* Override equals method in Object
* 重写Object 类中的equals 方法
*/
System.out.println("equals:" + str1.equals("abcdefgfedcba"));
System.out.println("equals:" + str1.equals(str2));
System.out.println("-----------------");
/*
* boolean equalsIgnoreCase(String str);
* 不区分大小写 判断当前调用方法字符串和参数字符串是否内容一致
*/
System.out.println("equalsIgnoreCase:" + str1.equalsIgnoreCase("ABCDEFGFEDCBA"));
System.out.println("equalsIgnoreCase:" + str1.equalsIgnoreCase(str2));
}
}
1.2.3 字符串转换方法
1、String(char[] arr);
【构造方法】将一个字符数组转换为字符串
2、String(char[] arr, int offset, int length);
【构造方法】将一个字符数组从指定下标 offset 开始 计数字符个数 length 转换为一个字符串
3、static String valueOf(char[] arr);
【静态方法】将一个字符数组转换为字符串
4、static String valueOf(char[] arr, int offset, int length);
【静态方法】将一个字符数组从指定下标 offset 开始 计数字符个数 length 转换为一个字符串
5、char[] toCharArray();
字符串数据内容转字符数组
import java.util.Arrays;
/*
* 字符串转换方法
*/
public class Demo4 {
public static void main(String[] args) {
char[] arr = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
/*
* String(char[] arr);
* 【构造方法】 将一个字符数组转换为字符串
*/
String str1 = new String(arr);
System.out.println("构造方法：" + str1);
System.out.println("----------------");
/*
* String(char[] arr, int offset, int length);
* 【构造方法】 将一个字符数组从指定下标位置 offset 开始 计算length 个字符 转换为字符串
*/
String str2 = new String(arr, 1, 4);
System.out.println("构造方法：" + str2);
System.out.println("----------------");
/*
* static String valueOf(char[] arr);
* 【静态方法】 将一个字符数组转换为字符串
*/
System.out.println("静态方法：" + String.valueOf(arr));
System.out.println("----------------");
/*
* static String(char[] arr, int offset, int length);
* 【静态方法】 将一个字符数组从指定下标位置 offset 开始 计算length 个字符 转换为字符串
*/
System.out.println("静态方法：" + String.valueOf(arr, 1, 4));
System.out.println("----------------");
/*
* char[] toCharArray();
* 字符串数据内容转字符数组
*/
String str3 = "hijklmn";
System.out.println("toCharArray:" + Arrays.toString(str3.toCharArray()));
}
}
1.2.4 字符串其它方法
1、String replace(char oldChar, char newChar);
将调用方法的字符串 指定的 oldChar 字符替换为 newChar 字符内容
最终替换结果通过方法返回值返回一个新的字符串
2、String[] split(String str);
将调用方法的字符串 根据参数字符串 str 进行分割
得到的结果是一个分割之后的字符串数组
3、String substring(int begin);
将调用方法字符串 从指定下标 begin 位置开始到字符串末尾 截取子字符串
4、String substring(int begin, int end);
将调用方法字符串 从指定下标 begin 位置开始到指定下标 end 位置结束 截取子字符串
截取的子字符串不包括下标 end 位置的元素
5、String toLowerCase();
将调用方法的字符串所有的英文字母全部转换为小写
结果通过返回值返回一个新的字符串
6、String toUpperCase();
将调用方法的字符串所有的英文字母全部转换为大写
结果通过返回值返回一个新字符串
7、String trim();
删除调用方法的字符串两端的无效空格
结果通过返回值返回一个新的字符串
【注意】
字符串是一个常量 字符串执行方法原串不变
所有的结果都是通过方法返回值返回的新的字符串
import java.util.Arrays;
/*
* 字符串其他方法
*
* 【注意】
* 字符串是一个常量 字符串执行方法原串不变
* 所有的结果都是通过方法返回值返回的新的字符串
*/
public class Demo5 {
public static void main(String[] args) {
String str = "ABCDEFGFEDBCA";
/*
* String replace(char oldChar, char newChar);
* 将调用方法的字符串 指定的 oldChar 字符替换为 newChar 字符内容
* 最终替换结果通过方法返回值返回一个新的字符串
*/
String str1 = str.replace('A', 'a');
System.out.println("replace:" + str1);
System.out.println("str:" + str);
System.out.println("--------------------");
/*
* String[] split(String str);
* 将调用方法的字符串 根据参数字符串 str 进行分割
* 得到的结果是一个分割之后的字符串数组
*/
String str2 = "id,name,age,gender,tel";
String[] arr1 = str2.split(",");
System.out.println("split：" + Arrays.toString(arr1));
System.out.println("str2：" + str2);
System.out.println("--------------------");
/*
* String substring(int begin);
* 将调用方法字符串 从指定下标 begin 位置开始到字符串末尾 截取子字符串
*/
String str3 = str.substring(3);
System.out.println("substring：" + str3);
System.out.println("str：" + str);
System.out.println("--------------------");
/*
* String substring(int begin, int end);
* 将调用方法字符串 从指定下标 begin 位置开始到指定下标 end 位置结束 截取子字符串
* 截取的子字符串不包括下标 end 位置的元素
*/
String str4 = str.substring(3, 7);
System.out.println("substring：" + str4);
System.out.println("str：" + str);
System.out.println("--------------------");
/*
* String toLowerCase();
* 将调用方法的字符串所有的英文字母全部转换为小写
* 结果通过返回值返回一个新的字符串
*/
String str5 = str.toLowerCase();
System.out.println("toLoweerCase：" + str5);
System.out.println("str：" + str);
System.out.println("--------------------");
/*
* String toUpperCase();
* 将调用方法的字符串所有的英文字母全部转换为大写
* 结果通过返回值返回一个新字符串
*/
String str6 = str5.toUpperCase();
System.out.println("toUpperCase：" + str6);
System.out.println("str5：" + str5);
System.out.println("--------------------");
/*
* String trim();
* 删除调用方法的字符串两端的无效空格
* 结果通过返回值返回一个新的字符串
*/
String str7 = " a b c ";
String str8 = str7.trim();
System.out.println("trim：" + str8);
System.out.println("str7：" + str7);
}
}
2、集合
2.1 集合的使用
1、容量不需要调用者考虑（有扩容）
2、支持数据类型多样化 但是严格遵循数据类型一致化要求（有泛型）
3、配套方法多 并且工具类多 且操作手段多
4、支持多元类型 方法复用度高 使用方便
2.2 集合类型的整体结构和类型特征分析
1、interface Collection<E>
Java 中所有集合的基类接口 规定了集合操作的基本方法
2、interface List<E> extends Collection<E>
Java 中 List 集合接口 继承了 Collection 接口同时增加了 List 接口特征方法
特征：有序、可重复
a、class ArrayList<E> implements List<E>
底层结构为 Object 类型的可变长数组
特征：增删慢、查询快
b、class LinkedList implements List<E>
底层结构为带有链表头的双向链表结构
特征：增删快、查询慢
c、class Vector<E> implements List<E>
底层结构为 Object 数据类型可变长数组
线程安全 性能对比 ArrayList 较差
3、interface Set<E> extends Collection<E>
Java 中 Set 集合接口 继承 Collection 接口
特征：无序，不可重复
a、class HashSet<E> implements Set<E>
底层结构为 哈希表结构 可以认为是 Excel 表格
b、class TreeSet<E> implements Set<E>
底层结构为 二叉树结构
2.3 Collection 集合常用方法
增
1、add(E e)
添加元素到集合
实例化集合对象过程中 泛型约束具体数据类型
2、addAll(Collection<? extends E> c);
添加参数集合到当前调用方法的集合中
要求参数集合存储的数据类型：
a、和调用方法的集合存储类型一致
b、调用方法的集合对象类型的子类
删
1、remove(Object obj);
删除调用方法的集合的指定元素
2、removeAll(Collection<?> c);
当前调用方法的集合 删除和参数集合的交集
3、retain(Collection<?> c);
当前调用方法的集合 仅保留和参数集合的交集
4、clear();
清空当前调用方法的集合
查
1、int size();
集合中有效元素个数
2、boolean isEmpty();
判断当前集合是否为空
3、boolean contains(Object obj);
判断参数对象元素是否在当前集合中的存在
4、boolean containsAll(Collection<?> c);
判断参数集合对象是否为当前集合的子集
5、Object[] toArray();
返回集合中所有存储元素的 Object 类型数组
【注意】
? 是通配符
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/*
* Collection 集合
*/
public class Demo1 {
public static void main(String[] args) {
/*
* Collection 是一个接口 无法实例化对象 无法调用目标方法
* Collection 接口的实现类 ArrayList 演示方法
*/
Collection<String> c1 = new ArrayList<String>();
/*
* add(E e)
* 添加元素到集合
* 实例化集合对象过程中 泛型约束具体数据类型
*/
c1.add("aaa");
c1.add("bbb");
c1.add("ccc");
c1.add("ddd");
c1.add("eee");
c1.add("fff");
System.out.println(c1);
System.out.println("----------------");
Collection<String> c2 = new ArrayList<String>();
c2.add("ggg");
c2.add("hhh");
c2.add("iii");
c2.add("jjj");
c2.add("kkk");
c2.add("mmm");
/*
* addAll(Collection<? extends E> c);
* 添加参数集合到当前调用方法的集合中
* 要求参数集合存储的数据类型：
* 1、和调用方法的集合存储类型一致
* 2、调用方法的集合对象类型的子类
*/
c1.addAll(c2);
System.out.println(c1);
System.out.println("----------------");
/*
* remove(Object obj);
* 删除调用方法的集合的指定元素
*/
c1.remove("kkk");
System.out.println(c1);
System.out.println("----------------");
Collection<String> c3 = new ArrayList<String>();
c3.add("ggg");
c3.add("hhh");
/*
* removeAll(Collection<?> c);
* 当前调用方法的集合 删除和参数集合的交集
*/
// c1.removeAll(c3);
// System.out.println(c1);
/*
* retainAll(Collection<?> c);
* 当前调用方法的集合 仅保留和参数集合的交集
*/
// c1.retainAll(c3);
// System.out.println(c1);
/*
* clear();
* 清空当前调用方法的集合
*/
c3.clear();
System.out.println("----------------");
/*
* int size();
* 当前调用方法的集合的有效元素个数
*/
System.out.println(c1.size());
System.out.println(c2.size());
System.out.println(c3.size());
/*
* boolean isEmpty();
* 判断当前调用方法的集合是否为空
*/
System.out.println(c1.isEmpty());
System.out.println(c3.isEmpty());
System.out.println("----------------");
Collection<String> c4 = new ArrayList<String>();
c4.add("aaa");
c4.add("bbb");
c4.add("ccc");
/*
* boolean contains(Object obj);
* 判断指定元素是否在当前调用方法的集合中存在
*
*/
System.out.println(c1.contains("bbb"));
/*
* boolean containsAll(Collection<?> c);
* 判断参数集合是否在当前调用方法的集合中存在
*/
System.out.println(c1.containsAll(c4));
System.out.println("----------------");
/*
* Object[] toArray();
* 返回集合中所有元素的 Object 类型数组
*/
Arrays.asList(c1.toArray()).forEach(System.out::println);
}
}
2.4 List 集合特征
特征：
1、数据存储默认尾插法，按照添加顺序有序存储
2、存储的元素可以相同
2.5 List 集合常用方法
增
1、add(E e)
添加元素到集合
实例化集合对象过程中 泛型约束具体数据类型
2、addAll(Collection<? extends E> c);
添加参数集合到当前调用方法的集合中
要求参数集合存储的数据类型：
a、和调用方法的集合存储类型一致
b、调用方法的集合对象类型的子类
3、add(int index, E e);
添加元素到集合指定下标位置
实例化集合对象过程中 泛型约束具体数据类型
4、addAll(int index, Collection<? extends E> c);
添加参数集合到当前调用方法的集合中指定下标位置
要求参数集合存储的数据类型：
a、和调用方法的集合存储类型一致
b、调用方法的集合对象类型的子类
删
1、E remove(int index);
删除当前集合中指定下标位置元素
返回值是被删除的元素
2、remove(Object obj);
删除调用方法的集合的指定元素
3、removeAll(Collection<?> c);
当前调用方法的集合 删除和参数集合的交集
4、retain(Collection<?> c);
当前调用方法的集合 仅保留和参数集合的交集
5、clear();
清空当前调用方法的集合
改
1、E set(int index, E e);
使用实例化对象数据类型的指定元素替换当前集合的指定 index 下标位置元素
返回值是被替换的元素
查
1、int size();
集合中有效元素个数
2、boolean isEmpty();
判断当前集合是否为空
3、boolean contains(Object obj);
判断参数对象元素是否在当前集合中的存在
4、boolean containsAll(Collection<?> c);
判断参数集合对象是否为当前集合的子集
5、Object[] toArray();
返回集合中所有存储元素的 Object 类型数组
6、E get(int index);
获取当前调用方法的集合的指定下标位置的元素
7、List<E> subList(int fromIndex, int toIndex);
获取当前调用方法的集合的 从指定下标位置 fromIndex 开始 到指定下标位置 toIndex结束 的子集
不包含 toIndex 下标位置的元素
8、int indexOf(Object obj);
在当前调用方法的集合中找出指定元素第一次出现的位置
9、int lastIndexOf(Object obj);
在当前调用方法的集合中找出指定元素最后一次出现的位置
import java.util.ArrayList;
import java.util.List;
/*
* List 集合中的方法
*/
public class Demo3 {
public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
/*
* add(E e);
* 添加元素到集合
* 实例化集合对象过程中 泛型约束具体数据类型
*/
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
list1.add("ddd");
list1.add("eee");
System.out.println(list1);
System.out.println("-----------------------");
List<String> list2 = new ArrayList<String>();
list2.add("aaa");
list2.add("bbb");
list2.add("ccc");
/*
* addAll(Collection<? extends E> c);
* 添加参数集合到当前调用方法的集合中
* 要求参数集合存储的数据类型：
* 1、和调用方法的集合存储类型一致
* 2、调用方法的集合对象类型的子类
*/
list1.addAll(list2);
System.out.println(list1);
System.out.println("-----------------------");
/*
* add(int index, E e);
* 添加指定元素到当前调用方法的集合的指定 index 下标位置
*/
list1.add(0, "zzz");
System.out.println(list1);
System.out.println("-----------------------");
List<String> list3 = new ArrayList<String>();
list3.add("www");
list3.add("xxx");
list3.add("yyy");
/*
* addAll(int index, Collection<? extends E> c);
* 添加参数集合到当前调用方法的集合的指定 index 下标位置
*/
list1.addAll(0, list3);
System.out.println(list1);
System.out.println("-----------------------");
/*
* E remove(int index);
* 删除当前集合中指定下标位置元素 返回值是被删除的元素
*/
System.out.println(list1.remove(0));
System.out.println(list1);
System.out.println("-----------------------");
/*
* remove(Object obj);
* 删除调用方法的集合的指定元素
*
* removeAll(Collection<?> c);
* 当前调用方法的集合 删除和参数集合的交集
*
* retain(Collection<?> c);
* 当前调用方法的集合 仅保留和参数集合的交集
*
* clear();
* 清空当前调用方法的集合
*/
/*
* E set(int index, E e);
* 使用实例化对象数据类型的指定元素替换当前集合的指定 index 下标位置元素
* 返回值是被替换的元素
*/
System.out.println(list1.set(0, "ooo"));
System.out.println(list1);
System.out.println("-----------------------");
/*
* int size();
* 当前调用方法的集合的有效元素个数
*/
System.out.println(list1.size());
System.out.println("-----------------------");
/*
* boolean isEmpty();
* 判断当前调用方法的集合是否为空
*
* boolean contains(Object obj);
* 判断指定元素是否在当前调用方法的集合中存在
*
* boolean containsAll(Collection<?> c);
* 判断参数集合是否在当前调用方法的集合中存在
*
* Object[] toArray();
* 返回集合中所有元素的 Object 类型数组
*/
/*
* E get(int index);
* 获取当前调用方法的集合的指定下标位置的元素
*/
System.out.println(list1.get(4));
System.out.println("-----------------------");
/*
* List<E> subList(int fromIndex, int toIndex);
* 获取当前调用方法的集合的 从指定下标位置 fromIndex 开始 到指定下标位置 toIndex结束 的子集
* 不包含 toIndex 下标位置的元素
*/
System.out.println(list1.subList(2, 5));
System.out.println("-----------------------");
/*
* int indexOf(Object obj);
* 在当前调用方法的集合中找出指定元素第一次出现的位置
*/
System.out.println(list1.indexOf("aaa"));
System.out.println("-----------------------");
/*
* int lastIndexOf(Object obj);
* 在当前调用方法的集合中找出指定元素最后一次出现的位置
*/
System.out.println(list1.lastIndexOf("aaa"));
}
}
638
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
