黑马程序员_JAVA笔记13——String、StringBuffer

------- android培训、java培训、期待与您交流！ ----------
1、String, 定义：public final class String
字符串是一个特殊的对象

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

String str = "abc“；//str是一个类类型变量，所以”abc"是一个对象，字符串最大的特点在于：一旦你被初始化就不可以被改变。(对象的引用可以变，对象不能变，“abc”不能变，但str可以变)

String str = new String("abc");

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

{
String str = "abc“;
str = "ab";//对象不变，但引用可以变

String str1 = new String("abc");//内存中两个对象，new的和”abc“

String str1 ="abc";//内存中就一个对象“abc"

System.out.println(str==str1);//结果：false

System.out.println(str.equals(str1));//结果；true，String类复写了Object类总的
//equals方法，该方法用于判断字符串是否相同。

}

}

2、
/*
String 类适用于描述字符串事物。
String提供了多个方法对字符串进行操作。
常见方法：
获取：

字符串中包含的字符数，也就是字符串长度。
int length()。

根据位置获取位置上某个字符。
char charAt(int index)。

根据字符获取该字符在字符串中第一次出现的位置。
int indexOf(int ch)

从fromIndex指定位置开始，获取ch在字符串出现的位置
int indexOf(int ch,int fromIndex);

根据str获取该字符串在字符串中第一次出现的位置。
int indexOf(String str)
从fromIndex指定位置开始，获取str在字符串出现的位置
int indexOf( String str ,int fromIndex);
获取字符ch从后到前的第一次出现的位置，也就是最后出现的位置，返回值是ch在字符串中的角标

int lastIndexOf(int ch)

判断：

字符串中是否包含某一个子串

boolean contains(str)

特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示该str不再字符串中存在。所以，也可以用于指定判断是否包含。if(str.indexOf("aa")!=-1)该方法既可以获取位置又可以判断

字符串中是否有内容

boolean isEmpty();原理就是判断长度是否为0

字符串是否以指定内容开头

boolean startsWith(str);

字符串是否以指定内容结尾

boolean endsWith(str);

判断字符串内容是否相同

boolean equals(str);

判断内容是否相同，并忽略大小写

boolean equalsIgnoreCase();

转换：

将字符数组转成字符串

构造函数：
String (char[]);

String (char[],offset,count)将字符数组中一部分转成字符串

静态函数：

static String copyValueOf(char[] value);将字符数组转成字符串

static String copyValueOf(char[] value,int offset,int count)将字符
数组中一部分转成字符串
static String valueOf(char[] value); 将字符数组转成字符串
将字符串转成字符数组

char[] toCharArray();

将字节数组转成字符串

String (byte[]);
String (byte[],offset,count)将字节数组中一部分转成字符串
将字符串转成字节数组

byte[] getBytes();

将基本数据类型转成字符串

static String valueOf(int)

static String valueOf(double)

特殊：字符串和字节数组在转换过程中，是可以指定编码表的

替换：

String replace(char oldChar,char newChar);//可以是单个字符，也可以是字符序列

切割：

String[] split(regex);以regex为分隔符，切割字符串，返回字符串数组，但是字符串中的regex在返回的字符串数组中就不存在了。

子串：

获取字符串中的一部分：

String substring(begin);

String substring(begin,end);

转换、去除空格、比较

将字符串转成大写或小写

String to UpperCase();

String to LowerCase();

将字符串两端多个空格去除

String trim();

对两个字符串进行自然顺序的比较

int compareTo(String);

*/

class StringDemo
{
public static void method_get()

{
String str = "abcdaefgsdf";

sop(str.length());

sop(str.charAt(3));//当访问到字符串中不存在的角标时，发生StringIndexOutOfBoundsException

sop(str.indexOf('a',3));//当字符串中找不到字符时，返回-1

sop(str.indexOf("ae");

sop(str.lastIndexOf('a'));

}

public static void method_is()

{
String str = "ArrayDemo.java";

sop(str.startsWith("Array"));

sop(str.endsWith(".java"));

sop(str.contains("Demo");

}

public static void method_trans()
{
char[] arr = {'a'.'e'.'r'.'v'.'c'.'q'.'g'};

String s = new String(arr,1,3);

sop(s);//结果erv，从e开始，3个字符

sop("s="+s);

String s1 = "zxcvbnm";

char[] chs = s1.toCharArray();

for(int x = 0;x<chs.length;x++)

{
sop(chs[x]);

}

}

public static void method_exchange()

{
String s = "hello java";

String s1 = s.replace('a','n');

String s1 = s.replace('q','n');//如果要替换的不存在，返回的是原串
String s2 = s.replace("java","world");//

sop(s);

sop(s1);

}

public static void method_split()

{
String s = "zhangsan,lisi,wangwu";

String[] arr = s.split(",");

for(int x=0 ;x<arr.length;x++)

{
sop(arr[x]);

}

}

public static void method_split()

{
String s = "zhangsan,lisi,wangwu";

sop(s.substring(2));//结果angsan,lisi,wangwu，从指定位置开始到结尾
//如果角标不存在，出现字符串角标越界异常

sop(s.substring(2,4));//结果an，包含头不包含尾，从2开始到4结束，包含2不包含4

}

public static void method_change()

{
String s = " hello JAVA ";

sop(s.toLowerCase());

sop(s.toUpperCase());

sop(s.trim());

String s1 = "abcd";

String s2 = "aaa";

sop(s1.compareTo(s2));//返回值是int，int值为第一个不同的字符之间的差，即s1中b 减去s2中a所得的差（编码值），一般我只需要知道是否大于0就可以了

}

public static void main(String[] args)

{

method_get();

}

public static void sop(Object obj)

{
System.out.println(obj);

}

}

3、StringBuffer，是字符串缓冲区，是一个容器。public final class StringBuffer{}，容器长度可变，内容数据类型不限。最终通过toString方法变成字符串
特点：
存储

StringBuffer append();将直盯盯数据作为参数添加到已有数据的结尾处

示例：

StringBuffer sb = new StringBuffer();

sb.append("abc").append(true).append(34);//方法链，方法返回的值为本类对象，因此可以继续调用本方法。

System.out.println(sb.toString());

StringBuffer insert(index,数据);可以将数据插入到指定index功能

删除

StringBuffer delete(start,end);删除缓冲区数据，包含start 不包含end

StringBuffer deleteCharAt(index);删除指定位置数据

清空缓冲区

StringBuffer sb = new StringBuffer("sfsdfdf");

sb.delete(0,sb.length());

获取

Char charAt(int index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start,int end);

修改

StringBuffer replace(int start,int end,String str);包含start不包含end

void setCharAt(int index,char ch);

反转

StringBuffer reverse();

获取缓冲区数据并存储到指定数组中

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

缓冲区开始 缓冲区结束 目的数组 目的数组开始位置

StringBuffer sb = new StringBuffer("fdfdsf");

char[] ch = new char[9];

sb.getChars(1,3,ch,1);//取出sb中1-2位置的数据，存储到数组ch，存储位置从1开始

4、StringBuilder
在jdk1.5之后，出现StringBuilder

区别：

StringBuffer是线程同步的，安全的

StringBuilder是线程不同步的，不安全的。建议单线程使用（单线程中，StringBuffer判断锁，StringBuilder不判断，因此后者效率要高一些），多线程使用StringBuffer或lock。

5、jdk升级的一般要素
提高效率

简化书写

提高安全性

6、基本数据类型对象包装类
byte Byte

short Short

int Integer

long Long

boolean Boolean

float Float

double Double

char Character

基本数据类型对象包装类的最常见作用：就是用于基本数据类型和字符串类型质检单饿转换
基本数据类型转成字符串：
基本数据类型+""
基本数据类型.toString(基本数据类型值) Integer.toString(34),将34转为“34”

字符串转成基本数据类型：
格式：XXX a = XXX.parseXXX(String s);
static int parseInt(String s)

int num = Integer.parseInt("123");System.out.println(num+5); 值为128
boolean b =Boolean.parseBoolean("true");

注意：
char不能转换，因为本身就是一个字符，直接使用方法就可以

int num = Integer.parseInt("123");的另一种书写方式
Integer i = new Integer("123");

int num = i.intValue();//非static方法intValue()，将Integer类型对象转为int

class IntegerDemo
{
public static void sop(String str)

{
System.out.println(str)

}

public static void main(String[] args)

{
sop("int max:"+Integer.MAX_VALUE);

}

}

十进制转成其他进制
toBinaryString();转为二进制

toOctalString();转为八进制

toHexString();转为十六进制

其他进制转为十进制：
static int parseInt(string,radix);//string表示其他进制的数值，radix表示的是几进制。合起来就是把radix进制的值string转为十进制

int x= parseInt("110",2);

特点：
一般写法：

Integer x = new Integer("123");

Integer y = new Integer(123);

System.out.println(x==y);//false，两个对象

System.out.println(x.equals(y));//true，比较的是数值是否相等。

1.5版本后新特新：自动数据类型转换，

如果是int x；x只能是int 数据；而如果是Integer x ，则x多了个值null（1.5后新特性）

Integer x = 123;//自动装箱，new Integer("123")

x= x+2;//x+2, x进行自动拆箱，变成int 类型（x.intValue()） ，和2进行运算，再将和进行装箱，赋给x。

Integer m = 128;

Integer n = 128;//因为128已经超过byte范围，所以新建了一个128

System.out.println(m==n);//false,因为new了两个对象

Integer a = 127;
Integer b = 127;//因为127已经存在，在byte范围内，所以b也指向了这个127
System.out.println(m==n);//true，因为a和b指向了同一个Integer对象。因为当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会再开辟新的空间。