javaseday15(String)

String类的特点

字符串是一个特殊的对象

字符串一旦被初始化就不可以被改变

比如 s="abc"  abc 不变  s 可以指向不同的

字符串常量池 没有abc就创个abc 然后把abc的地址赋给s  后面再指向abc的对象  2个 地址值相等

  

java lang 包是核心类 自动导入

util 是utiliy的缩写 意为多用途的工具性质的包

String s1 = new String("abc");//创建了2个对象一个new 一个字符串对象 在堆内存中

String 复写了Object 中的equals  其实就是比较字符串内容  

ctrl+m 将当前界面最大化

创建字符串 ""

字节数组转化成字符串 要查表

在方法里面继承父类的方法已经复写了 不然就出现在方法继承父类那里

 * 按照面向对象的思想对字符串的功能进行分类
* "abcd"
* 1、获取
* 1.1 获取字符串中字符的个数(长度)
* int length();
* 1.2 根据位置获取字符
* char charAt(int index)
* 1.3 根据字符获取在字符串的位置 第一次出现的位置 通过ascii
* int indexof(int ch) 
* int indexof(int ch,int fromIndex) 从指定位置进行ch的查找
* int indexof(String  str) 查找字符串
* int lastIndexOf(int ch)从后往前
* int lastIndexOf(int ch,int fromIndex)指定位置从后往前
* int lastIndexOf(String str)从后往前
* int lastIndexOf(String str,int fromIndex)从后往前

从后往前数的时候还是按照角标的数字

. 是正则中的特殊符号 可以转译成 普通点 \\.

基本数据类型比较用> < 之类 字符串比较用compareTo

* 1.4获取字符串中一部分的字符串也叫字串
* String substring(int beginIndex,int endIndex) 不包括尾部 长度为endIndex-beginIndex 因为s.length()-1正好是最后一个角标
* 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 oldChar,char newChar) 没替换成功就返回原来的字符串
* 2.6将字符串两端的空格去除
* String trim();不然有用户前面和后面加空格不知道 不能校验
* 2.7将字符串进行连接
* String concat(String); 和+差不多 但是 concat 比较专业 对对象进行操作
*3、判断
* 3.1两个字符串内容是否相同？
* boolean equals(Object obj)
* boolean equalsIgnoreCase(String anotherstr) 忽略大写比较字符串内容
* 3.2 字符串是否包含
* boolean contains(String str)
* 3.3 字符串是否一指定字符串开头 是否以指定字符串结尾
* boolean startsWith(String str)
* boolean endsWith(String str) 找文件后缀
*
* int compareTo字典顺序比较两个字符串。 比较是基于字符串中每个字符的Unicode值 如果参数字符串等于此字符串，则值为0 ; 一个值小于0如果这个字符串的字典比字符串参数小; 如果此字符串的字典大小超过字符串参数，则值大于0 。 
* 比较依据自身 是对象之间的比较
* intern() 对字符串池中的操作  是共享数据
*
*
*
*/
String s = "java";
String s1 = s.replace("b", "c");
System.out.println(s==s1);

/*
 * 字符数组的排序
 * 给定一个字符串数组 按照字典顺序进行从小到大排序
 * 思路
 * 1、对数组进行排序 可以用选择 冒泡
 * 2、for 嵌套和比较以及换位
 * 3、问题 以前排的是证书 比较用的是比较运算符 现在是字符串对象
 *  字符串对象怎么比较  对象中提供了用于字符串对象比较的功能compareTo
 *
 */
public class StringDemo04 {
public static void main(String[] args) {
String[]  s = {"abc","sss","bbc","ssd"};


printArray(s);
sortArray(s);
System.out.println();
printArray(s);
}


private static void printArray(String[] s) {
System.out.print("[");
for (int i = 0; i < s.length; i++) {
if (i != s.length - 1) {
System.out.print(s[i] + ",");
} else
System.out.print(s[i] + "]");
}
}


private static void sortArray(String[] s) {
for (int i = 0; i < s.length-1; i++) {
for (int j = i+1; j < s.length; j++) {
if(s[i].compareTo(s[j])>0){ //字符串比较用comparetTo完成
swap(s,i,j);
}
}
}
}


private static void swap(String[] s, int i, int j) {
String temp = s[i];
s[i]=s[j];
s[j]=temp;


}
}

public class StringDemo {
public static void main(String[] args) {


/*
* 一个字串在整串中出现的次数
* "dsdasdas"
* 思路：
* 1、要找的字串是否存在 如果存在获取其出现的位置 这个可以用indexof完成
* 2、如果找到了那么就记录出现的位置 并在剩余的字串中继续查找该字串
* 而剩余字符串的起始位就是出现位置+字串长度
* 3、以此类推 通过循环完成 如果找不到就是-1 并对每次找到用计数器记录
*
*
*/
String s = "ddsadsaa";
String key = "d";


int  b = getKeyStringCount(s,key);
System.out.println(b);


}
/**
* 获取子串在整串中出现的次数
* @param s
* @param key
* @return count
*/
public static int getKeyStringCount(String s, String key) {
//1、定义计数器
int count = 0;


//2、定义变量记录key出现的位置
int index = 0;


while((index=s.indexOf(key))!=-1){//-1才是不存在 
s = s.substring(index+key.length()); //会出现很多字符串
count++;
};


return count;
}
}

public static int getKeyStringCount2(String s, String key) {
int count = 0;
int index = 0;


while((index = s.indexOf(key,index))!=-1)
{
index = index+key.length();
count++;
}
return count;
}

用新获得索引查找原来的字符串 不会产生新的字符串

还有一个 用切割 split 但是可能为切出空的

/*
 * 两个字符串中最大相同的子串
 * "qwewqqwesdafg"
 * "sdwaa"
 * 思路
 * 1、既然取的最大的字符串 先看短的那个字符串是否在长的那个字符串中
 * 如果存在短的那个字符串就是最大子串
 * 2、如果不是 那么就将短的那个字串进行长度递减的方式取子串 去长串中判断是否存在
 * 如果存在就已找到 就不用找了
 */
public class StringDemo02 {
public static void main(String[] args) {
String s1 = "qwewqqwesdafg";
String s2 = "sdwaa";
String s = getMaxSub(s1,s2);
System.out.println(s);
}


public static String getMaxSub(String s1, String s2) {
String max=null, min=null;
max = s1.length()>s2.length()?s1:s2;
min = max.equals(s1)?s2:s1;
for (int i = 0; i < min.length(); i++) {
for(int a = 0,b= min.length()-i;b!=min.length()+1;a++,b++){
String sub = min.substring(a, b);
if(max.contains(sub))
return sub;
}
}
return null;
}
}

/*
 * 模拟一个trim 功能一致的方法去除字符串两端的空白
 * 思路
 * 1、定义两个变量
 * 一个变量作为从头开始判断字符串空格的角标不断(循环)++
 * 一个变量作为从尾开始判断字符串空格的角标不断(循环)--
 * 2、判断到不是空格为止 取头尾之间的字符串即可
 *
 */
public class StringDemo03 {
public static void main(String[] args) {
String s= "  dd s ";
System.out.println("-"+s+"-");
s = myTrim(s);
System.out.println("-"+s+"-");
}


private static String myTrim(String s) {
int start = 0 , end = s.length()-1;
while (start<=end && s.charAt(start)==' '){
start++;
}
while (start<=end && s.charAt(end)==' '){
end--;
}
return s.substring(start, end+1);
}
}

/*
 * 模拟一个trim 功能一致的方法去除字符串两端的空白
 * 思路
 * 1、定义两个变量
 * 一个变量作为从头开始判断字符串空格的角标不断(循环)++
 * 一个变量作为从尾开始判断字符串空格的角标不断(循环)--
 * 2、判断到不是空格为止 取头尾之间的字符串即可
 *
 */
public class StringDemo03 {
public static void main(String[] args) {
String s= "  dd s ";
System.out.println("-"+s+"-");
s = myTrim(s);
System.out.println("-"+s+"-");
}


private static String myTrim(String s) {
int start = 0 , end = s.length()-1;
while (start<=end && s.charAt(start)==' '){
start++;
}
while (start<=end && s.charAt(end)==' '){
end--;
}
return s.substring(start, end+1);
}
}

public class StringBuffer01 {
public static void main(String[] args) {
/*
* StringBuffer 字符串缓冲区
* 用于存储数据的容器 数组也是容器 其实就是一个默认为16的数组
* 特点:
* 1、长度是可变的
* 2、可以存储不同类型的数据
* 3、最终要转成字符串进行使用
* 4、可以对字符串进行修改
*
* 既然是个容器应该有什么功能
* 1、添加：不能加byte short 但是可以用int接收
* StringBuffer  append(data);
* StringBuffer  insert(index,data);
* 2、删除：
* StringBuffer delete(start,end) 包含头不包含尾
* StringBuffer deleteCharAt(int index) 删除指定位置的元素
*3、查找
* char charAt(index)
* int indexOf(String)
* int lastIndexOf(String)
*4、修改
* replace(int start, int end, String str) 
* 用指定的String中的字符替换此序列的子字符串中的 String 
* void setChar(int index,char);
*增删改查 curd
* setLength(); 设置长度 可以清空缓存区 过长 用空字符'\u0000' 
* reverse();反转
*StringBuffer(int capacity) 
* 构造一个没有字符的字符串缓冲区和指定的初始容量。
*指不指定初始容量 看要用多少大小的
*
*/
BufferMethod2();
}
private static void BufferMethod2() {
StringBuffer sb = new StringBuffer("asdas");
//清空缓冲区
sb.delete(0, sb.length());
//新建缓冲区
//sb = new StringBuffer();

}
private static void BufferMethod1() {
StringBuffer sb = new StringBuffer("abc");
sb.append("xx");
sb.insert(1,"dage");
System.out.println(sb);// adagebcxx


}
public static void BufferMethod(){
StringBuffer sb = new StringBuffer();
sb.append(4).append(true).append("aa");//方法调用链
StringBuffer s1= sb.append(4);
System.out.println(sb);
System.out.println(s1==sb); //true
}
}