String 类 与 特点
(你说一下 “” 与equals 区别？)
1**.字符串是一个特殊的对象** String str= “abc” "abc"是一个对象 str 是类变量
String str=“abc”;
str=“bbb”;// 引用变量重新指向字符串 “bbb” ,当是之前的 "abc"不会改变。
String s1=“abc”;
**System.out.println(s1s) ;??? true** 指向同一个地址。（选择题）
解释：字符串在字符串常量区 如果没有“abc”则创建，当String s1=“abc”; 因为已经存在“abc”,所以地址赋值给s1;
（总结：字符串定义的第一种方式，字符串常量区无则建立，有则直接用）。
2.字符串一但初始化就不能改变可共享。
对于基本数据类型 “== ”比较的是“值” ，对于String 比较的是地址。对于equals方法，注意：equals方法不能作用于基本数据类型的变量
如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
面试题下面两种创建对象有什么区别？
String s =“abc”;//常量池中产生一个对象
String s1= new String(“abc”);//创建两个对象一个 new 一个字符串对象在堆内存中。
System.out.println(s==s1);// flase
System.out.println(s.equals(s1));// true 重点： String 类对 Object 本来是比较对象地址的 equals 方法依据自身要求进行了覆写----比较的是内容不是地址。
常见API 使用
/*
- 按照面向对象的思想对字符串进行功能分类。
- “abcd”
- 1,获取：
- 1.1 获取字符串中字符的个数(长度).
- int length();
- 1.2 根据位置获取字符。
- char charAt(int index);
- 1.3 根据字符获取在字符串中的第一次出现的位置.
- int indexOf(int ch)
- int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
- int indexOf(String str);
- int indexOf(String str,int fromIndex);
- 根据字符串获取在字符串中的第一次出现的位置.
- int lastIndexOf(int ch)
- int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
- int lastIndexOf(String str);
- int lastIndexOf(String str,int fromIndex);
- 1.4 获取字符串中一部分字符串。也叫子串.
- String substring(int beginIndex, int endIndex)//包含begin 不包含end 。
- String substring(int beginIndex);
- 2，转换。
- 2.1 将字符串变成字符串数组(字符串的切割)
- String[] split(String regex):涉及到正则表达式.
- 2.2 将字符串变成字符数组。
- char[] toCharArray();
- 2.3 将字符串变成字节数组。
- byte[] getBytes();
- 2.4 将字符串中的字母转成大小写。
- String toUpperCase():大写
- String toLowerCase():小写
- 2.5 将字符串中的内容进行替换
- String replace(char oldch,char newch);
- String replace(String s1,String s2);
- 2.6 将字符串两端的空格去除。
- String trim();
- 2.7 将字符串进行连接 。
- String concat(string);
- 3，判断
- 3.1 两个字符串内容是否相同啊？
- boolean equals(Object obj);
- boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。
- 3.2 字符串中是否包含指定字符串？
- boolean contains(string str);
- 3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。
- boolean startsWith(string);
- boolean endsWith(string);
- 4，比较。
- 5.public String intern()
返回字符串对象的规范表示。
最初为空的字符串池由String类String 。
当调用intern方法时，如果池已经包含与equals(Object)方法确定的相当于此String对象的字符串，则返回来自池的字符串。
否则，此String对象将添加到池中，并返回对此String对象的引用。
由此可见，对于任何两个字符串s和t ， s.intern() ==
t.intern()是true当且仅当s.equals(t)是true
。
*/
package string;
public class StringDemo {
public static void main(String[] args) {
// 02String类 构造函数
String s= new String();// 知识点1： 等价于 String s="" ;“” 是一个对象 不等于 String s=null 这个是空 ;
//知识点2 ： String(byte[] bytes) 字节数组-----》构造一个新的String
byte arr[]=new byte[]{97,66,67};
String s2= new String(arr);
System.out.println(" s2="+s2);
//字符数组
char arr2[]= new char[]{'a','b','c'};
String s3= new String(arr2,0,1);//一部分变成字符串
System.out.println("s3:"+s3);
//字符串
String s4="boo:and:foo";
String[] s4_1=s4.split(":");
for(int i=0;i<s4_1.length;i++){
System.out.println(" s4_1:"+s4_1[i]);
/***
* s4_1:boo
* s4_1:and
* s4_1:foo
*
*/
}
//按照正则表达式匹配
System.out.println("字符串切割 split");
String s5="张三,李四,王五";
// String[] s5_1=s5.split(",");
String[] s5_1=s5.split("\\,");
for(int i=0;i<s5_1.length;i++){
System.out.println(" s5_1:"+s5_1[i]);
/***
*
*/
}
String s6="abc";
char[] chs= s6.toCharArray();
for(int i=0;i<chs.length;i++){
System.out.println("chs "+chs[i]);// a b c
}
// getBytes
s6="ab你";
byte[] bytes =s6.getBytes();
for(int i=0;i<bytes.length;i++){
System.out.println(bytes[i]);
}// 97 98 -28 -67 -96
//将所有在此字符 String使用默认语言环境的规则大写。
s="abcd";
System.out.println(s.toUpperCase());
// 字符替换
System.out.println(s.replace('a','z'));// zbcd
s="the war of baronets".replace('r', 'y');
System.out.println(s);
String S1 = "java";
String S2 = S1.replace('q', 'z');//不包含q
System.out.println(S1==S2);//true
System.out.println("S1:"+S1);
System.out.println("S2:"+S2);
//trim()
//返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。
System.out.println(" a b c ".trim());//a b c
//判断字符串内容是否相同?
String s8_1="abc";
String s8_2="abcd";
System.out.println(s8_1.equals(s8_2));//false
//equalsIgnoreCase不区分大小写判断字符串是否相同
String s8_3="Abc";
String s8_4="abc";
System.out.println(s8_3.equalsIgnoreCase(s8_4));//true
//字符串中是否包含子串
String s9_1="Abc_zengjx";
String s9_2="zeng";
System.out.println(s9_1.contains(s9_2));//true
// 3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。
String s10_1="Abc_zengjx";
String s10_2="Abc";
String s10_3="jx";
System.out.println(s10_1.startsWith(s10_2));//true
System.out.println(s10_1.endsWith(s10_3));//true
//public String intern()返回字符串对象的规范表示。
//对于任何两个字符串s和t ， s.intern() == t.intern()是true当且仅当s.equals(t)是true 。
String s11_1="Abc";
String s11_2=s11_1.intern();
System.out.println(s11_1==s11_2);//true
String s11_3 = new String("abc");// new 两个对象
String s11_4=s11_3.intern();//获取字符串池中的数据 是共享数据
System.out.println("intern "+(s11_4==s11_3));//false
System.out.println("equals"+(s11_4.equals(s11_4)));//true
}
}练习
练习1
/*
- 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。
- {“nba”,“abc”,“cba”,“zz”,“qq”,“haha”}
- 对数组排序 选择 冒泡 比较字符串对象public int compareTo(String anotherString)
- 如果String对象按字典顺序排列在参数字符串之前，结果为负整数。
结果是一个正整数，如果String对象按字典顺序跟随参数字符串。
如果字符串相等，结果为零; compareTo返回0 ，当equals(Object)方法将返回true
。
*/
package string;
//字典序字符串
public class StringTest1 {
public static void main(String[] args) {
sort1demo();
}
public static void sort1demo(){
String s[]= new String[] {"nba","abc","cba","zz","qq","haha"};
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
}
sortString(s);
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
}
sortStringByBable(s);
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
}
}
//选择
public static void sortString(String[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i;j<arr.length-1;j++){
if( arr[j].compareTo(arr[j+1])>0){
String temp= arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
//冒泡
public static void sortStringByBable(String[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if( arr[i].compareTo(arr[j])>0){
String temp= arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
}2，一个子串在整串中出现的次数。“nbaernbatynbauinbaopnba” “nba”
思路： 使用public int indexOf(String str,int fromIndex)
返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
如果不存在这样的k值，则返回-1 。
public static void test2(){
String s1= "nbaernbatynbauinbaopnba";
String s2="nba";
String s3="aaa";
// 用例 1
int count= subStringTimes(s1,s2);
System.out.println(" count ="+count);
// 用例 2
count= subStringTimes(s1,s3);
System.out.println(" count ="+count);
// 用例3
count= subStringTimes(null,null);
System.out.println(" count ="+count);
}//子串出现次数 "nbaernbatynbauinbaopnba" "nba"
public static int subStringTimes(String arr,String subarr){
if(arr==null ||arr.length()==0||subarr==null ||subarr.length()==0){
return -1;
}
int index=0;
int count =0;
int fromIndex=0;
while (true){
index= arr.indexOf(subarr,fromIndex);
if(index!=-1){
count++;
fromIndex=index+subarr.length();
}else{
break;
}
}
return count;
}
3，两个字符串中最大相同的子串。
String test1 =“qwerabcdtyuiop”;
String test2=“xcabcdvbn”;
//求两个字符串最大子串
// 1. str2 是否是str1 的字串 如果是则str2 是最大字串
//2. str2 如果不是str1字串则 str2 -1个字符 遍历这个长度的字符串
//直到 str2长度为1
public static void test3(){
String test1 ="qwerabcdtyuiop";
String test2="xcabcdvbn";
System.out.println(maxSubString(test1,test2));
String test3 ="aaaaaaaabbbbbbb";
String test4="aba";
System.out.println(maxSubString(test3,test4));
String test5 ="aaaaaaabcd";
String test6="abcd";
System.out.println(maxSubString(test5,test6));
}
/** 设 s2 = abcd
* leng= 4 abcd 4-0 length()-i 当前字符串长度
* leng=3 abc bcd 4-1
* leng=2 ab bc cd 4-2
* leng= 1 a b c d 4-3
* for(int i=0;i<s2.length();i++){// 字符串长度遍历
* for(j=0; j<=i;j++){
* }
*
*
*
* }
*
*
*
* @param str1
* @param str2
* @return
*/
public static String maxSubString(String str1,String str2){
if(str1==null ||str1.length()==0||str2==null||str2.length()==0){
return null;
}
String max= str1.length() > str2.length() ? str1:str2;
String min =max.equals(str1) ? str2:str1;
//min="abcd";
for(int i=0;i<min.length();i++){
int length=min.length()-i;
for(int j=0;j<=i;j++){
String sub=min.substring(j,j+length);
// System.out.println(sub);
if( max.contains(sub)){
System.out.println("find "+sub);
return sub;
}
}
// return null;
// System.out.println(" -------"+" i "+i);
}
return null;
}
4，模拟一个trim功能一致的方法。
/***
* 实现思路index 下标 charAt(index);
* 先前面 匹配" "
* 如果匹配到则 inde
* 然后从 length 往前遍历
*
*
* @param src
* @return
*/
public static void mytrimtest(){
String s=" qqq ";
System.out.println("取出后:["+mytrim(s)+"]");
System.out.println("取出后:["+mytrim(" ")+"]");
}
//
public static String mytrim(String src){
if(src==null || src.length()==0){
return null;
}
int index=0;
String string= src;
while(string.length()>0){
char ch=string.charAt(index);
if(ch==' '){
index++;
System.out.println(" left index"+index);
string=string.substring(index) ;
System.out.println("length="+string.length());
index=0;
}else {
break;
}
}
if(string.length()==0){
return "";
}
index=string.length()-1;
while (string.length()>0){
char ch= string.charAt(index);
if(' '==ch){
string= string.substring(0,index);
index--;
System.out.println(" right index"+index);
}else{
break;
}
}
return string;
}
扫一扫
98
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
