package com.String;
public class Study01 {
public static void main(String[] args){
Study01 sd=new Study01();
sd.testCompareTo();
}
public void testGouZao(){
String s1=new String();
System.out.println("s1:"+s1);
System.out.println("s1.length:"+s1.length());
System.out.println("------------");
byte[] bytes={97,99,101,107};
String s2=new String(bytes);//先转char再连接
System.out.println("s2:"+s2+"\ns2.length:"+s2.length());
System.out.println("---------------");
String s3=new String(bytes,1,3);
System.out.println("s3:"+s3+"\ns3.length:"+s3.length());
//...char数组和byte数组基本一致
String s4=new String("sgh");//这种方式没有太大意义
System.out.println("s4:"+s4+"\ns4.length:"+s4.length());
String s5="sgh";
System.out.println("s5:"+s5+"\ns5.length:"+s5.length());
System.out.println(s4.equals(s5));
System.out.println(s4==s5);
}
public void testNotChange(){
String s="hello";
s+="world";
System.out.println("s:"+s);//==>helloworld
//这里我的理解是：一个字符串对应一个值，该值在方法区变量池中不会改变，只能堆积。
}
public void testStringAnd(){
//String拼接
//字符串如果是变量相加，先开空间，再拼接
//字符串如果是常量相加，是先加，然后在常量池找。如果有就直接返回，否则就创建
String s1="hello";
String s2="world";
String s3="helloworld";
System.out.println(s3==s1+s2);//false
System.out.println(s3.equals(s1+s2));//true
System.out.println(s3=="hello"+"world");//true
System.out.println(s3.equals("hello"+"world"));//true
}
public void testbj(){
String s1="helloworld";
String s2="helloworld";
String s3="HelloWorld";
//boolean equals(Object obj)比较字符串的内容是否相同，区分大小写
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println("---------------------------");
//boolean equalsIgnoreCase(Object obj)比较字符串的内容是否相同，不区分大小写
System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.equalsIgnoreCase(s3));
System.out.println("--------------------");
//boolean contains(String str) 比较字符串中是否包含某小字符串
System.out.println(s1.contains("hll"));
System.out.println("----------");
//startsWith(String str)比较字符串是否以某个字符串开头
//startsWith(String str,int offerset)比较字符串从offerset位置开始是否以str开头
System.out.println(s1.startsWith("h"));
System.out.println(s1.startsWith("ow", 4));
//endsWith(String str)比较字符串是否以某个字符串结尾
System.out.println(s1.endsWith("d"));
System.out.println("----------------");
String s4=new String();
System.out.println(s4.isEmpty());
String s5="";
System.out.println(s5.isEmpty());
}
public void testCompareTo(){
System.out.println("hello".compareTo("sss"));//-11
System.out.println("hello".compareTo("hel"));
}
}
/**
* java lang 包，不需要导入
* 版本JDK1.0开始
* 字符串：
* 一串字符由特殊方式连接起来，可以理解成为字符数组的特殊表示
* 字符串的值存储在方法区的常量区里面
* 构造方法：
* 其他在类型都是转换成为char类型才开始连接
* String()
* String(byte[] bytes)
* String bytes,Charset charset)
* String(byte[] bytes,int offset,int length) 由字节数组的第几位开始，多少长度连接成字符串。
* String(char[] value)
* String(char[] value,int offest,int count)
* String(String original)把常量值转化成字符串
*
* 常用方法：
* length()
* 字符串可以理解成字符数组，所以获取字符串长度的方式：length()方法
* equals()
* 前面讲Object类型的时候我们知道，String类型的equals方法自动重写成为了比较值
* toString()
* toString()方法自动重写了，显示的是该字符串的值
* 字符串的特点：一旦赋值，就不能更改
* String s="aaa";和String s=new String("aaa");的区别：
* 前者创建一个或者两个对象，后者创建0个或者1个对象
* ==和equals的区别：
* 前者比较的是内存地址是否相同，后者Object中的默认比较也是内存地址是否相同，不过String方法重写了该方法，比较的是内容是否相同
*
* 比较方法：
* boolean contains(String str):判断大字符串中是否包含小字符串
* boolean startsWith(String str):判断大字符串是否以某个指定的字符串开头
* boolean endsWith(String str):判断大字符串是否以某个指定的字符串结尾
* boolean isEmpty():判断字符串是否为空
* boolean matches(String regex) 告知此字符串是否符合该正则表达式
* 获取方法：
* length() 获取字符串长度
* char charAt(int index) 获取指定索引位置的字符
* int indexOf(int ch):返回指定字符在字符串中第一次出现的索引，如果没有返回-1.为什么这里是int类型，以你为所有的字符都可以使用int在Ascill中找到
* int indexOf(String str):返回指定字符在字符串中第一次出现的索引
* int indexOf(String str,int formIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引
* String substring(int start):从指定位置截取字符串，默认到末尾
* String substring(int start,int end):从指定开始位置截取到指定结束位置的字符串 左闭右开区间
* 转换方法：
* byte[] getBytes()把字符串转换成为字节数组
* char[] toCharArray() 将字符串转换为字符数组
* static String valueOf(char[] chs):将字符数组转换成字符串
* static String valueOf(int i) 将int、类型的而数据转换成字符串
* String toLowerCase() 将字符串转为小写
* String toUpperCase() 将字符串转换成大写
* String concat(String str):将字符串拼接
* 其他方法：
* 拆分：public String[] split(String regex) 根据给定正则表达式拆分字符串
* 替换：
* String replace(char old,char new); 将原字符串中的old字符全部使用new字符替换掉
* String replace(String old,String new)
* 替换：
* public String replaceAll(String regex,String replacement) 使用给定的字符串替换本字符串中所有匹配给定正则表达式的子字符串
* public String replaceFirst(String regex,String replacement) 使用给定的字符串替换本字符串中第一个匹配给定正则表达式的子字符串
*
* 去除两边空格：
* String trim()
* 按字典顺序比较两个字符串
* int compareTo(String str)
* int compareToIgnoreCase(String str)
* compareTo方法解析：
* 从0下标的位置开始比较两个字符串的对应位置的字符是否相同，如果不同，得到的比较值就是前者的不同位置的字符的Ascall码-后者的Ascall码。如果没有字符的是相同的话，得到的结果是前者字符串的长度-后者字符串的长度
*/
package com.String;
import java.util.Scanner;
public class StringTest {
public static void main(String[] args){
StringTest st=new StringTest();
st.pjString();
}
public void test01(){
String name="admin";
String password="admin";
Scanner sc=new Scanner(System.in);
for(int i=2;i>=0;i--){
System.out.println("请输入用户名：");
String username=sc.nextLine();
System.out.println("请输入密码：");
String password1=sc.nextLine();
if(username.equals(name)&&password1.equals(password)){
System.out.println("登陆成功!");
break;
}else{
if(i==0){
System.out.println("账号被锁定，请与管理员联系！");
return;
}
System.out.println("登陆失败，还有"+i+"次机会");
}
}
}
public void test02(){
/* 遍历字符串中的每一个字符*/
Scanner input=new Scanner(System.in);
System.out.println("请输入字符串：");
String str=input.nextLine();
for(int i=0;i<str.length();i++){
System.out.println(str.charAt(i));
}
}
public void test03(){
/**
* 统计一个字符串中大写字母，小写字母，数字字符出现的次数
* 0 -- 48
* A -- 65
* a -- 97
*/
Scanner input=new Scanner(System.in);
System.out.println("请输入字符串：");
String str=input.nextLine();
int bigCount=0;
int smallCount=0;
int numCount=0;
for(int i=0;i<str.length();i++){
int x=str.charAt(i);
if(x>=48&&x<=58){
numCount++;
}else if(x>=65&&x<97){
bigCount++;
}else if(x>=97&&x<=123){
smallCount++;
}
}
System.out.println("大写字母"+bigCount+"个");
System.out.println("小写字母"+smallCount+"个");
System.out.println("数字"+numCount+"个");
}
public void toFormat(){
/* 将字符串的首字母转换成为大写，其他转化成小写*/
String str="saadAASDDsasddAA";
/*String str1=str.substring(0,1);
String str2=str.substring(1);
str1=str1.toUpperCase();
str2=str2.toLowerCase();
str=str1.concat(str2);
System.out.println(str);*/
String result=str.substring(0,1).toUpperCase().concat(str.substring(1).toLowerCase());
System.out.println(result);
}
public void pjString(){
/* 把数组中的数据拼接成字符串*/
int[] arr={1,2,3};
String s="[";
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
s+=arr[i]+"]";
}else{
s+=arr[i]+",";
}
}
System.out.println("最终的字符串是："+s);
}
}
View Code
package com.StringBuffer;
/*
* 线程安全
* 安全--同步--数据是安全的
* 不安全--不同步--效率高一些
* 安全与效率的问题是永远困扰我们的问题
* 安全：医院网站，银行网站
* 效率：论坛网站
*
* StringBuffer
* 线程安全的可变字符
* StringBuffer与String的区别：
* 前者长度和内容可变，后者不可变
* 如果使用前者做字符串的拼接，不会浪费太多资源
*
* StringBuffer的构造方法：
* public StringBuffer() 无参构造，容量16
* public StringBuffer(int capacity) 指定容量的字符串缓冲区
* public StringBuffer(String str)指定字符串内容的字符缓冲区对象，容量为16+length
* public StringBuffer(CharSequence seq) 构造一个带参字符缓冲区，包含于指定的CharSequence相同的字符
* CharSequence是一个接口，已知的实现类：CharBuffered，Segment，String，StringBuffer，StringBuilder
*
* 添加功能：
* append(String str)为例，可以将任何类型添加到StringBuffer中去,并返回字符串缓冲区本身
* insert(int offerset,String str) 以String的为例，将任意类型插入到字符缓冲区指定位置,原来的往后面推移字符串的长度
* 删除功能：
* delete(int start,int end) 删除字符缓冲区指定位置开始到指定位置结束的元素。
* deleteCharAt(int index) 删除字符缓冲区指定位置的字符
* indexOf(String str) 查找第一次出现的下标
* lastIndexOf(String str) 查找最后一次出现的下标
* 替换功能
* replace(int start,int end,String str) 将start到end中的字符用str替代
* reverse() 将字符缓冲区逆序
* setCharAt(int index,char ch) 用指定字符替换掉指定下标的字符
* 截取功能：跟string一样
* substring(String str)
* substring(int start,int end)
* 设置长度
* setLength()
*
* StringBuilder类是StringBuffer的一个替代产品，StringBuffer是线程安全的，但是效率更低，StringBuilder是线程不安全的，但是效率高，api用法一致
*/
public class Study01 {
}
