黑马程序员--Java基础之String类和基本数据类型对象包装类
------- android培训、java培训、期待与您交流！ ----------
今天是Java基础学习第13天，学习进度到String类和基本数据类型对象包装类，之前因为技术分不够，不知道日记书写规格如何，写的都不符合，今天正好够分数了。下面是今天的学习内容。
内容提纲：
1，String类及其各种用法
2，StringBuffer
3，基本数据类型对象包装类及其操作
一、String类
（1）String是一个类类型，由final修饰，不能继承，刚开始接触Java时，定义字符串类型的变量 String的首字母需要大写就感觉挺奇怪的，因为以前学C语言一直把string看做是和int、float数据类型一样的定义变量的数据类型，敲代码是又发现String和System的颜色是红色的，就去查资料才发现原来String还是一种类类型。
结合例子可知道：
字符串最大特点：一旦被初始化就不能改变
String s1 = "abc"; //s1是一个类类型变量，abc是一个对象
String s2 = new String("abc"); //s2是引用类型指向一个新的对象
System.out.println(s1==s2); //结果是false，因为比较的是s1和s2的地址值，不同，
System.out.ptintln(s1.equals(s2)); //String类复写了Object类中equals方法
//结果是true，该方法用于判断字符串是否相同
//s1和s2最大区别
//s1在内存中有一个对象
//s2在内存中有两个对象
（ 2），String类适用于描述字符串事物，它就提供了多个方法对字符串进行操作
1，获取
1.1 字符创中包含的字符数，也就是字符创的长度
int length(); 获取长度，返回int类型
1.2 根据位子获取位子上某个字符
char charAt(int index);，返回char类型
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在字符串中出现的位置
int lastIndexOf(str.indexOf("as"));
2,判断
2.1字符串中是否包含某一个字符串
boolean contains(str);
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1，表示该str不存在字符串中，
所以，也可以用于对指定字符判断是否包含
if(str.indexOf("aa")!=-1)
而且该方法既可以判断，也可以获取出现的位置
2.2 字符串是否有内容
boolean isEmpty(): 原理就是判断长度是否为0
2.3 字符串是否是以指定内容开始
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾
boolean endsWith(str);
2.5 判断字符串内容是否相同，复写了Object类中的equals方法
boolean equals(str)
2.6 判断内容是否相同，并忽略大小写
boolean equalsIgnoreCade();
3,转换
3.1 将字符数组转换成字符串
构造函数：String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串
静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] ,offset,count)
static String valueOf(char[]);
3.2 将字符串转成字符数组；****
char[] toCharArray();
3.3 将字节数组转成字符串
String(byte[])
string(byte[],offset,count)
3.4将字符串转成字节数组
byte[] getByte();
3.5,将基本数据类型转换成字符串
static String valueOf(int);
static String valueOf(double)
3+""; //String.valueOf(3);
特殊：字符串和字节数组在转换过程中，是可以指定编码表的
4,替换
1.1 String replace(oldchar,newchar )
5,切割
String[] split(regex);
6，子串，获取字符串中的一部分
String substring(begin);
String substring(begin,end);//包含头，不包含尾
7,转换，去除空格，比较
7.1将字符串转换成大写或小写
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除
String trim();
7.3对两个字符串进行自然顺序的比较
int compareTo(String)
实例用法
class StringMethodDemo
{
public static void method_7()
{
String s = " Hello Java ";
sop(s.toUpperCase());
sop(s.toLowerCase());
sop(s.trim());
String s1 = "abs";
String s2 = "aaa";
sop(s1.compareTo(s2));
}
public static void method_sub()
{
String s = "aljgankjkdj";
sop(s.substring(2));
sop(s.substring(2,6));
}
public static void method_split()
{
String s = "zhangsan,lisi,wangwu";
String[] arr = s.split(",");
for (int x=0;x
sop(arr[x]);
}
}
public static void method_replace()
{
String s = "hello java";
String s1 = s.replace('a','n');
sop("s="+s);
sop("s1="+s1);
}
public static void method_tran()
{
char[] arr = {'a','s','d','f','e','q','y'};
String s = new String(arr);
sop("s="+s);
String s1 = "akjagkagkh";
char[] arr1 = s1.toCharArray();
for (int x=0;x
sop("arr1="+arr1[x]);
}
}
public static void method_is()
{
String str = "ArrayDemo.java";
sop(str.startsWith("Array"));
sop(str.endsWith(".java"));
sop(str.contains("Demo"));
}
public static void getString()
{
String str = "abcdasljaglkjef";
sop(str.length());
sop(str.charAt(8));
sop(str.indexOf('a'));
sop(str.indexOf('a',6));
sop(str.indexOf("as"));
}
public static void main(String[] args)
{
//getString();
//method_is();
//method_tran();
//method_replace();
//method_split();
//method_sub();
method_7();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
练习一；
/*
练习
1，需求：先判断开始位置是不是空格，是空格继续往后判断，直到不是空格，取值,字符串去掉两端空格,
思路：1，有一个字符串（ abc jdl ）,使用trim()方法可以直接得出去掉空格后的字符串,
但本题的思路是：先判断字符串开始的位置是否是空格，获取字符串上某个位置上的字符使用方法 String charAt(int);
取得字符串的一部分使用 String.substring(start,end);
*/
class StringTest1
{
public static void main(String[] args)
{
String s = " abc jdl ";
sop("("+s+")");
String s1 = myTrim(s);
sop("("+s1+")");
}
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--;
str = str.substring(start,end+1);//获取一部分字符串
return str;
}
public static void sop(String str)//输出函数，封装好的，可多次调用，便利啊
{
System.out.println(str);
}
}
练习二
/*
需求：将字符串反转
思路：1，有一个字符串（ ab cd ），先把字符串编程字符数组 char[] toCharArray();
2,将字符数组反转使用for循环，位子交换，前面的后面的交换
3，交换后的字符数组，变成字符串 String(char[])
*/
class StringTest2
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String str = " ab cd ";
sop("("+str+")");
sop("("+reverseString(str)+")");
}
public static String reverseString(String s)
{
char[] arr = s.toCharArray(); //字符串变成字符数组
reverse(arr); //字符数组反转 (这快调用函数没有返回值，就把前后的字符反转了？怎么做到的？)
return new String(arr); //字符数组变成字符串
}
public static void reverse(char[] arr)
{
for (int start=0,end=arr.length-1;start
swap(arr,start,end);
}
}
public static void swap(char[] arr,int x,int y)//数组中元素位子交换
{
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
练习三；
/*
需求：获取一个字符串在另一个字符串中出现的次数
"kk" "abkksdkkdkkrekkf"
思路：1，首先要知道在大的字符串中是否含有kk，（indexOf()）有的话，标记位置,还需要计数
2，计数后，还要判断后面的字符是否还有kk,( substring() ) 使用循环
//方法一
class StringTest3
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String str="abkksdkkdkkrekkf";
sop("scount="+getSubCount(str,"kk"));
}
public static int getSubCount(String str,String key)
{
int count=0;
int index=0;
while ((index=str.indexOf(key))!=-1) //循环体用于判断在str字符串中key字符串出现的位子并赋值给index，结果不是-1表示str中存在key，再次循环
{
sop("str="+str);
str = str.substring(index + key.length()); //获取str字符串的部分，从出现key的位子加上key的长度开始计算
count++;
}
return count;
}
}*/
//方法二
class StringTest3
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String str="abkksdkkdkkrekkf";
sop("count="+getSubCount_2(str,"kk")); //不建议使用切割求字符串数组
}
public static int getSubCount_2(String str,String key)
{
int count=0;
int index=0;
while ((index=str.indexOf(key,index))!=-1)
{
sop("index="+index);
index=index+key.length();
count++;
}
return count;
}
}
练习四：
/*
需求：两个字符串，长度不一样，求短的字符串在长的字符串中最大的子集，并打印
"kahellocfk" "afejvhellocafkakfh"
思路：由短的每次减0个字符就可以有1个比较数,循环1次结束
由短的每次减1个字符就可以有2个比较数,循环2次结束
由短的每次减2个字符就可以有3个比较数,循环3次结束
由短的每次减3个字符就可以有4个比较数,循环4次结束
使用大圈套小圈思路，嵌套循环
*/
class StringTest4
{
public static String getMaxString(String s1,String s2)
{
//判断s1，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
//y表示开始比较的位子，z表示有几个数字参加比较,要从短的字符串中取数字是 sunstring(y,z),取y到z之间的数
for (int y=0,z=min.length()-x;z!=min.length()+1 ;y++,z++ )
{
String temp = min.substring(y,z);
if (max.contains(temp)) //可以理解判断短的字符串与长字符串最大公约数
{
return temp;
}
//sop("temp="+temp);
}
}
return "";
}
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s1="kahellocfk";
String s2="fkakfh";
sop("maxString---"+getMaxString(s1,s2));
}
}
（3）StringBuffer
/*
StringBuffer 是字符串缓冲区
是一个容器 （与数组想比较）
特点：1而且长度是可变化的。
2，可以操作多个数据类型
3，最总会通过toString()方法变成字符串
CURD数据操作
C creat U update R read D delete
1 存储
StringBuffer append(); 将指定数据作为参数添加到已有数据结尾处
StringBuffer insert(index,数据);可以将数据插入到指定index位置
2，删除
StringBuffer delete(start,end);删除缓冲区中的数据，包含start，不包含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(srart,end,string);
void setCharAt(int index,char ch);
5，反转
StringBuffer reverse();
6,将缓冲区中的指定数据存储到指定字符数组中；
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);
7,在JDK版本后出现了StringBuilder
StringBuffer 是线程同步
StringBuilder 是线程不同步（多用于单线程）
升级三因素：1提高效率2简化书写3，提高安全性
开发多使用StringBuilder
*/
class StringBufferDemo
{
public static void main(String[] args)
{
//method_replace();
StringBuffer sb = new StringBuffer("abcdefgh");
char[] chs = new char[6];
sb.getChars(1,4,chs,1);
for (int x=0;x
sop("chs["+x+"]="+chs[x]+";");
}
}
public static void method_replace()
{
StringBuffer sb = new StringBuffer("abcde");
sb.replace(2,4,"java");
sop(sb.toString());
}
public static void method_delete()
{
StringBuffer sb = new StringBuffer("abcde");
//sb.delete(2,3);
sb.deleteCharAt(2);
sop(sb.toString());
}
public static void method_add()
{
StringBuffer sb = new StringBuffer();
sb.append("zzh").append(52);
sb.insert(1,"qq");
sop(sb.toString());
//sop(sb);数据类型不是string
}
public static void sop(String str)
{
System.out.println(str);
}
}
（4）基本数据类型对象包装类
/*
基本数据类型 引用类型
byte Byte
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象包装类的最常见作用
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
基本数据类型+"";
基本数据类型.toString(基本数据类型值);
如： Interger.toString(34); //将34整数变成 "34";
*/
class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
sop(""+Integer.MAX_VALUE);
}
}
/*
基本数据类型对象包装类
基本数据类型 引用类型
byte Byte
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象包装类的最常见作用
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
基本数据类型+"";
基本数据类型.toString(基本数据类型值);
如： Interger.toString(34); //将34整数变成 "34";
字符串转换成基本数据类型
int i = Integer.parseInt("123")
doubel d= Double.parseDouble(""154.23);
Boolean b = Boolean.parseBoolean("true")
十进制转成其他进制
toBinaryString();
toHexString();
toOctalString();
其他进制转换成十进制
Integer.parseInt("",)
*/
class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//sop(""+Integer.MAX_VALUE);
//讲一个字符串转成整数
//int num = Integer.parseInt("125");
//sop("num="+(num+10));
//sop(Integer.toBinaryString(6)); //十进制转成二进制
//int num = Integer.parseInt("1110",2); 前后统一
int num = Integer.parseInt("3c",16);
sop(""+num);
}
}
//Integer x = new Integer(4);
//Integer x = 4; //可以指向null
//x为引用数据类型（类类型变量）指向对象，
//4为对象相当于new Integer(4);自动装箱
x = x + 4; //x+2: 运算过程分析，x进行自动拆箱(x.intValue())，变成了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
//结果为true，因为a和b指向了同一个Integer对象
//因为当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会再开辟新的空间