String类
StringBuffer
StringBuilder
基本数据类型
API：（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。
--< java.lang >--String字符串：★★★☆
java中用String类进行描述。对字符串进行了对象的封装。这样的好处是可以对字符串这种常见数据进行方便的操作。对象封装后，可以定义N多属性和行为。
如何定义字符串对象呢？String s = "abc";只要是双引号引起的数据都是字符串对象。
字符串最大特点：字符串一旦被初始化，就不可以被改变，存放在方法区中的常量池中。
------------------------------------------------------
String s1 = "abc"; // s1指向的内存中只有一个对象abc。s1是一个类类型变量，"abc"是一个对象。
String s2 = new String("abc"); // s2指向的内容中有两个对象abc、new 。
//s1和s2有什么区别？s1代表一个对象，在内存中有一个对象，s2有两个对象
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true ，String类复写了object类中equals方法，字符串中equals比较的是字符串内容是否相同。
-------------------------------------------------------
String 类适用于描述字符串事物,那么它就提供了多个方法对字符串进行操作.
常见的操作有哪些呢？
1，获取 。
1.1字符串中包含的字符数，也就是字符串的长度
int length();获取长度
1.2根据位置获取位置上的某个字符
char charAt（int index）
1.3根据字符获取该字符在字符串中位置
int indexof（int ch）;放回的是ch在字符串中第一次出现的位置
int indexof（int ch，int fromIndex）从fromindex指定的 位置开始，获取ch在字符串中出现的位置
int indexof（string str）;放回的是str在字符串中第一次出现的位置
int indexof（string str ，int fromIndex）从fromindex指定的 位置开始，获取str在字符串中出现的位置
2，判断
2.1 字符串中是否包含某一个子串boolean contains(str);
特殊之处：indexof（str）：可以索引str第一次出现位置，如果返回-1，表示该str不在字符串中存在，所以，也可以用于对指定字符串的判断是否包含If（str.indexOf(“aa”)!=-1）
而且该方法既可以判断，又可以获取出现的位置。
2.2字符中是否有内容1.6版
boolean isEmpty();原理就是判断长度是否为0，“”，null有区别。
2.3字符串是否是以指定内容开头
boolean startsWith(str);
2.4字符串是否是以指定内容结尾
boolean endsWith(str);
2.5判断字符串内容是否相同，复写了object类中的equals方法
boolean equals(str);
2.6判断内容是否相同，并忽略大小写
boolean equalsIgnoreCase();
3.转换
3.1，将字符数组转成字符串
构造函数：string（char[]）
String(char[] ,offset,count);将字符数组中的一部分转成字符串。
静态方法：
Static string copyValueof(char[]);
Static string copyValueof(char[] data,int offset,int count);
Static string Valueof(char[]);
3.2，将字符串转成字符数组***
Char[]toCharArray();
3.3，将字符数组转成字符串
String(byte[])
String(byte[] ,offset,count);将字节数组中的一部分转成字符串。
3.4，将字符串转成字节数组
Byte[] getBytes();
3.5，将基本数据类型转成字符串
Static string valueOf(int);
Static string valueOf(double);
3+””;//string.valueOf(3);
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
4，替换
String replace(oldchar,newchar);
5，切割
String[] split(regex);
6，子串，获取字符串中的一部分
String substring(begin,end);
7，转换，去除空格，比较
7.1将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();
7.2将字符串两端的多个空格去除
String trim();
7.3对两个字符串进行自然顺序的比较
Int compareTo(string);
public class stringDemo2 {
public static void main(String[]agrs)
{ method_7();
method_sub();
method_split();
method_replace();
method_trans();
method_is();
method_get();
String s1="abc";
String s2=new String("abc");
String s3="abc";
System.out.print(s1==s2);//false
System.out.print(s1==s3);//true
}
public static void method_7()
{
String s=" Hello Java ";
sop(s.toUpperCase());
sop(s.toLowerCase());
sop(s.trim());
String s1="abc";
String s2="aaa";
sop(s1.compareTo(s2));
}
public static void method_sub()
{
String s="abdddsga";
sop(s.substring(2));//从指定位置到结尾。如果角标不存在，会出现字符串角标越界异常。
sop(s.substring(2, 4));//包含头，不包含尾。s.substring(0,s.length)
}
public static void method_get()
{
String str="abcdse";
//长度
sop(str.length());
//根据索引获取字符
sop(str.charAt(4));//当访问到字符串中不存在的角标时会发送stringIndexoutofBoundsException
//根据字符获取索引
sop(str.indexOf('a'));
sop(str.indexOf('a',3));//如果没有找到返回-1.
//反向索引一个字符出现的位置，
sop(str.lastIndexOf("a"));
}
public static void method_split()
{
String s="zhangshan,lisi,wangwu";
String[] arr=s.split(",");
for(int x=0;x<arr.length;x++)
{
sop(arr[x]);
}
}
public static void method_replace()
{
String s="hello.java";
String s1=s.replace('a', 'n');//如果要替换的字符不存在，放回原串。
String s2=s.replace("java", "vorld");
sop("s="+s);
sop("s1="+s1);
}
public static void method_trans()
{ char[] arr={'a','b','c','d','e','f'};
String s=new String(arr);
String s1=new String(arr,1,3);
sop("s="+s);
String s2="agdsdfasdg";
char[] chs=s2.toCharArray();
for(int x=0;x<chs.length;x++)
{
sop("chs="+chs[x]);
}
}
public static void method_is()
{
String str="arraydemo.java";
//判断文件名称是否是array单词开头
sop(str.startsWith("array"));
//判断文件名称是否是。Java文件
sop(str.endsWith(".java"));
//判断文件名中是否包含demo
sop(str.contains("demo"));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
字符串练习
1、模拟一个trim方法，去除字符串两端的空格
思路：1，判断字符串第一个位置是否是空的，如果是继续向下判断，直到不是空格为止，结尾处判断空格也是如此
2，当开始和结尾都判断到不是空格时，就是要获取的字符串
2、将一个字符串进行反转，将字符串中指定部分进行反转，“abcdefg”;”abfedcg”
思路：1，曾经学习过对数组的元素进行反转
2，将字符串变成数组，对数组反转
3，将反转后的数组变成字符串
4，只要将或反转的部分的开始和结束位置作为参数传递即可
3、获取一个字符串在另一个字符串中出现的次数
“abkkcdkkefkkskk”
思路：1，定义个计数器
2，获取kk第一次出现的位置
3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。每获取一次就计数一次
4，当获取不到时，计数完成。
4、获取两个字符串中最大相同子串，第一个动作，将短的那个串进行长度一次递减的子串打印
“abcwerthelloyuiodef”
“cvhellobnm”
思路：
1，将短的那个子串按照长度递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含，如果包含，已经找到！
public class stringpraces {
public static void main(String[] args) {
// TODO Auto-generated method stub
//sop("count====="+str.split("kk").length);//在练习三中不建议使用
String s1="asdkjfhalsdjfasdf";
String s2="asd";
sop(getMaxSubString(s1,s2));
String str="abkkdcdskkdsfakkdfg";
sop("count"+getSubCount(str,"kk"));
String s=" ab cd ";
sop("("+s+")");
s=myTrim(s);
sop("("+s+")");
sop("("+reverseString(s)+")");
sop("("+reverseString(s，6，9)+")");
}
//练习4：
public static String getMaxSubString(String s1,String s2)
{
String max="",min="";
max=(s1.length()>s2.length())?s1:s2;
min=(max==s1)?s2:s1;
sop("max="+max+"......"+"min="+min);
for(int x=0;x<min.length();x++)
{
for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)
{
String temp=min.substring(y,z);
// sop(temp);
if(max.contains(temp));//if(s1.indexof(temp)!=-1)
return temp;
}
}
return "";
}
//练习三2：获取一个字符串在另一个字符串中出现的次数
public static int getSubCount2(String str,String key)
{
int count=0;
int index=0;
while(str.indexOf(key,index)!=-1)
{ sop("index="+index);
index=index+key.length();
count++;
}
return count;
}
//练习三1：获取一个字符串在另一个字符串中出现的次数
public static int getSubCount(String str,String key)
{
int count=0;
int index=0;
while((index=str.indexOf(key))!=-1)
{
sop("str="+str);
str.substring(index+key.length());
count++;
}
return count;
}
//练习二：将字符串反转
//思路
//1，将字符串变成数组
//2，对数组反转
//3，将数组变成字符串
public static String reverseString(String s,int start,int end)
{
//字符串变数组
char[] chs=s.toCharArray();
//反转数组
reverse(chs,start,end);
//将数组变成字符串
return new String(chs);
}
public static String reverseString(String s)
{
//字符串变数组
//char[] chs=s.toCharArray();
//反转数组
//reverse(chs);
return reverseString(s,0,s.length());
}
private static void reverse(char[] arr,int x,int y)
{
for(int start=x,end=y-1;start<end;start++,end--)
{
swap(arr,start,end);
}
}
private static void swap(char[] arr,int x,int y)
{ char temp;
temp=arr[x];
arr[x]=arr[y];
arr[y]= temp;
}
//练习一，去除字符串两端空格
public static String myTrim(String str)
{
int start=0,end=str.length()-1;
while(start<=end&&str.charAt(start)==' ')
start++;
while(start<=end&&str.charAt(end)==' ')
end--;
return str.substring(start, end+1);
}
public static void sop(String str)
{
System.out.println(str);
}
}
《《《《——————————————》》》》
--< java.lang >--StringBuffer字符串缓冲区：★★★☆
StringBuffer
构造一个其中不带字符的字符串缓冲区，初始容量为 16个字符。
字符串的组成原理就是通过该类实现的。StringBuffer可以对字符串内容进行增减
StringBuffer是一个容器，很多方法与String相同，StringBuffer是可变长度的，StringBuffer是字符串缓冲区。
特点：
1：可以对字符串内容进行修改。
2：是一个容器。
3：是可变长度的。
4：缓冲区中可以存储任意类型的数据。
5：最终需要变成字符串。
c creat u update r read d delete
1，存储
StringBuffer append():将指定数据作为参数添加到已有数据结尾处
StringBuffer insert(index, 数据);可以将数据插入到指定位置
2，删除，
StringBuffer delete(int start,int end);删除缓冲区中的数据，包括头不包括尾。
StringBuffer deleteCharAt(index);删除指定位置的字符。
3，获取
char charAt(int index)
int indexOf(String str)
int lastindexOf(String str)
int length()
String substring(int start,int end)
4，修改
StringBuffer replace(int start,int end,String str)替换一部分
void setCharAt(int index,char ch)替换一个字符
5，反转
StringBuffer reverse();
6，将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)
--< java.lang >--StringBuilder字符串缓冲区：★★★☆
JDK1.5出现StringBuiler；构造一个其中不带字符的字符串生成器，初始容量为 16个字符。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
方法和StringBuffer一样；
jdk1.5版本之后出现了StringBuilder
StringBuffer是线程同步，StringBuilder是线程不同步
以后开发，建议使用StringBuilder
将StringBuilder的实列用于多个线程是不安全的，如果需要这样的同步则建议使用StringBuffer
StringBuffer 和 StringBuilder 的区别：
StringBuffer线程安全。
StringBuilder线程不安全。
单线程操作，使用StringBuilder 效率高。
多线程操作，使用StringBuffer 安全。
Java升级三个因素：
1，提高效率
2，简化书写
3，提高安全性
---------------------------------------------------------
StringBuilder sb = new StringBuilder("abcdefg");
sb.append("ak"); //abcdefgak
sb.insert(1,"et");//aetbcdefg
sb.deleteCharAt(2);//abdefg
sb.delete(2,4);//abefg
sb.setLength(4);//abcd
sb.setCharAt(0,'k');//kbcdefg
sb.replace(0,2,"hhhh");//hhhhcdefg
//想要使用缓冲区，先要建立对象。
StringBuffer sb = new StringBuffer();
sb.append(12).append("haha");//方法调用链。
String s = "abc"+4+'q';
s = new StringBuffer().append("abc").append(4).append('q').toString();
---------------------------------------------------------
class Test{
public static void main(String[] args) {
String s1 = "java";
String s2 = "hello";
method_1(s1,s2);
System.out.println(s1+"...."+s2); //java....hello
StringBuilder s11 = new StringBuilder("java");
StringBuilder s22 = new StringBuilder("hello");
method_2(s11,s22);
System.out.println(s11+"-----"+s22); //javahello-----hello
}
public static void method_1(String s1,String s2){
s1.replace('a','k');
s1 = s2;
}
public static void method_2(StringBuilder s1,StringBuilder s2){
s1.append(s2);
s1 = s2;
}
}
《《《《————————————————————》》》》
---------------------------------------------------------
--< >--基本数据类型对象包装类：★★★☆
基本数据类型对象包装类：是按照面向对象思想将基本数据类型封装成了对象。
好处：
1：可以通过对象中的属性和行为操作基本数据。
2：可以实现基本数据类型和字符串之间的转换。
基本数据类型对象包装类
关键字 对应的类名
byte 基本数据类型 ，有自己定义的对象叫： Byte 这个是类，是引用数据类型
short Short paserShort(numstring);
int Integer 静态方法：parseInt(numstring)
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象包装类：都有 XXX parseXXX方法
只有一个类型没有parse方法：Character ；
--------------------------------------------------------
Integer对象：★★★☆
数字格式的字符串转成基本数据类型的方法：
1：将该字符串封装成了Integer对象，并调用对象的方法intValue();
2：使用Integer.parseInt(numstring):不用建立对象，直接类名调用；
将基本类型转成字符串：
1：Integer中的静态方法 String toString(int);
2：int+"";
基本数据类型对象包装类的最常见作用
就是用于基本数据类型和字符串类型之间做转换
1. 基本数据类型转成字符串
基本数据类型+“”
基本数据类型.toString(基本数据类型值)；
如：Integer.toString(34);//将34整数变成“34”；
2. 字符串转成基本数据类型
xxx a=Xxx.parseXxx(string);
int a=Integer.parseInt(string);这个是静态调用方式
boolean b=Boolean.parseBoolean("true")
//**Integer i=new Integer("123");
int num=i.intValue();//这个方法是非静态的 这个是对象调用方式*/
十进制转成其他进制
toBinaryString();
toHexString();
toOctalString();
其他进制转成十进制
parseInt(string,radix)
在jdk1.5版本后，对基本数据类型对象包装类进行升级。在升级中，使用基本数据类型对象包装类可以像使用基本数据类型一样，进行运算。
Integer i = new Integer(4); //1.5版本之前的写法；
Integer i = 4; //自动装箱，1.5版本后的写法；
i = i + 5;
//i对象是不能直接和5相加的，其实底层先将i转成int类型，在和5相加。而转成int类型的操作是隐式的。自动拆箱：拆箱的原理就是i.intValue();i+5运算完是一个int整数。如何赋值给引用类型i呢？其实有对结果进行装箱。
Integer c = 127;
Integer d = 127;
System.out.println(c = = d); //true
//在装箱时，如果数值在byte范围之内，那么数值相同，不会产生新的对象，也就是说多个数值相同的引用指向的是同一个对象。
public class jibenshujuleixingbaozhuanglei {
System.out.println(Integer.MAX_VALUE);
public static void main(String[] args) {
//将一个字符串转成整数
int num=Integer.parseInt("a123");//必须传入数字格式的字符串
long x=Long.parseLong("123");
sop("num="+(num+4));
sop(Integer.toBinaryString(6));
sop(Integer.toBinaryString(-6));
int y=Integer.parseInt("110", 10);//将进制形式，转成后面对应的十进制值。
int z=Integer.parseInt("3c", 16);
sop("x="+x);
sop(Integer.toHexString(60));
//整数类型的最大值，
sop("int max:"+Integer.MAX_VALUE);
}
public static void sop(String str)
{
System.out.println(str);
}
}
jdk1.5版本以后出现的新特性
public class IntegerDemo1 {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
//Integer x=new Integer(4);
Integer x=4;//自动装箱。1.5中可以这样写。//4等同于new Integer(4);null为空时，亦抛出异常
x=x+2;/ *拆箱原理：x.intValue()*///x+2：x进行了自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x
Integer m=128;
Integer n=128;
sop("m==n:"+(m==n));//结果：false
Integer a=127;
Integer b=127;
sop("a==b:"+(a==b));//结果：true。因为a和b指向了同一个Integer对象
//因为当数值在byte范围-128-127内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。
}
public static void method()
{Integer x=new Integer("123");
Integer y=new Integer(123);
sop("x==y"+(x==y));
sop("x.equals(y):"+x.equals(y));
}
public static void sop(String str)
{
System.out.println(str);
}
}
———寄语：明天，你好。等我们累死了，会有人蹲下来给我们一个温暖的拥抱吗？我想会有的，因为你还有两个心脏在为你跳动，为了担心。所以啊，濛濛好好加油吧。再苦再累也是值的。濛濛努力中。。。——— 濛濛
1037
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
