第一 String类
一、概述：
字符串是最常用的类型之一，所以为了使用方便java就给封装成了对象方便使用。String类型的一旦被初始化就不能再改变。
String s1 = "abc";//s1是一个类类型变量， "abc"是一个对象。//字符串最大特点：一旦被初始化就不可以被改变。
s1 = "kk";//字符串abc是没有改变的，只是s1指向对象变了，也就是说kk并没有改变abc的值，只是又多了一个字符串对象是kk，然后用s1指向这个新的字符串对象。定义方式：String s2 = new String("abc");//存放在堆内存中
String s3 = "abc";//字符串存放在常量池中，而且是以字符的形式存放s2在内存中有两个对象，因为abc就是一个对象，然后把abc的对象存放在new关键字创建在堆内存中的对象中；s3在内存中只有一个对象。
二、常量池：
因为String类型一旦被初始化是不能被改变的，所以存放在常量池，存放在常量池中还有个很重要的原因：String s1 = “abs”；String s2=“abs”，这时s2并没有新建立一个对象，而是指向了s1这个对象。也就是说每当创建一个字符串时，并不是直接创建而是先到常量池中区找需要创建的对象是否存在，如果存在就不会再创建了。常量池中的元素是不会重复的，这也就是所谓的享元模式，例如当已经存在abs，这时需要创建ahk，这时常量池中只会增加两个字符h和k，然后在从常量池中抽出ahk对象。
三、特点：
1、String是一种特殊的数据类型，可创建对象。
2、通过String创建的对象分别可存在于常量池和堆内存中
3、String是一个final的类型，即不可被继承修改，一经初始化就终生不可改变。（要改变也是改变的引用）
4、常量池中的数据可共享，即两个引用变量可指向同一个字符串池中的字符串
5、Java中的任何对象都可写成字符串的形式。
6、既然String是对象，那就不得不说说null和“”的区别了。null是String对象指向为空，就是没有指向。而“”代表的是String对象指向的是一个空的字符串。
四、字符串常见的操作方法：（String str = "hello java"）
1、获取。
1.1 字符串中的包含的字符数，也就是字符串的长度。
int length():获取长度。str.length()//结果为10
1.2 根据位置获取位置上某个字符。
char charAt(int index)://charAt(1)，结果是e
1.3 根据字符获取该字符在字符串中位置。//indexOf(’l‘)结果是2
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(int ch) ：从后往前找，但是字符串中的角标是没有变的。
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 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);
String substring(begin,end);
7，转换，去除空格，比较。
7.1 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除。
String trim();
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);//大于返回正数，等于返回0，小于返回负数，且值为ASSII值之差。
public class StringDemo {
public static void main(String[] args) {
String str = "asdfghjaszxsa.java";
method_get(str);
print("------------------------------------------");
method_is(str);
print("------------------------------------------");
method_transform(str);
print("------------------------------------------");
method_replace(str);
print("------------------------------------------");
method_split(str);
print("------------------------------------------");
method_sub(str);
print("------------------------------------------");
method_change();
}
/*
* String获取方法 凡是获取的字符或者是字符串不存在，就返回-1
*/
private static void method_get(String str) {
// 获取字符串的长度
int length = str.length();
print("length: " + length);
// 根据位置获取位置上的某个字符
char ch = str.charAt(1);
print("ch: " + ch);
// 根据字符获取该字符在字符串中的位置
int index = str.indexOf("index: " + 'a');// 获取该字符第一次出现的位置
print("index: " + index);
// int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexf = str.indexOf('a', 2);
print("indexf: " + indexf);
// int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexs = str.indexOf("as");
print("indexs: " + indexs);
// int indexOf(String str, int fromIndex)
// :从fromIndex指定位置开始，获取str在字符串中出现的位置。
int indexsf = str.indexOf("as", 3);
print("indexsf: " + indexsf);
// int lastIndexOf(int ch)
int indexlast = str.lastIndexOf('a');
print("indexlast: " + indexlast);
}
/*
* String中的判断
*/
private static void method_is(String str) {
// 字符串中是否包含某一个子串
/*
* 特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。
* 所以，也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1) 而且该方法即可以判断，有可以获取出现的位置。
*/
boolean iscon = str.contains("asd");
print("iscon: " + iscon);
// 字符中是否有内容。boolean isEmpty(): 原理就是判断长度是否为0.
boolean isemp = str.isEmpty();
print("isemp: " + isemp);
// 字符串是否是以指定内容开头。boolean startsWith(str);
boolean start = str.startsWith("asd");
boolean startoffset = str.startsWith("sd", 1);
print("start: " + start);
print("startoffset: " + startoffset);
// 字符串是否是以指定内容结尾。boolean endsWith(str);
boolean end = str.endsWith(".java");
print("end: " + end);
// 判断字符串内容是否相同。复写了Object类中的equals方法。boolean equals(str);
boolean equal = str.equals("asdfghjaszxsa.java");
print("equal: " + equal);
// 判断内容是否相同，并忽略大小写。boolean equalsIgnoreCase();
boolean equ = "AASD".equalsIgnoreCase("Aasd");
print("equ: " + equ);
}
/*
* 转换
*/
private static void method_transform(String str) {
char[] chs = { 'a', 's', 'd', 'f', 'g' };
byte[] bts = { 'a', 's', 'd', 'f', 'g' };
// 将字符数组转成字符串
String trChStr = new String(chs);
String trChStrO = new String(chs, 1, 3);
print("trChStr: " + trChStr + "....trChStrO: " + trChStrO);
String copyvalueof = String.copyValueOf(chs);
print("copyvalueof: " + copyvalueof);
// 将字符串转成字符数组****
char[] tochar = str.toCharArray();
for (int x = 0; x < tochar.length; x++) {
print("char[" + x + "] = " + tochar[x]);
}
// 将字节数组转成字符串。
String trBtStr = new String(bts);
String trBtStrO = new String(bts, 1, 3);
print("trBtStr: " + trBtStr + "....trBtStrO: " + trBtStrO);
// 将字符串转成字节数组。byte[] getBytes():
// 特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
byte[] getBts = str.getBytes();
for (int x = 0; x < getBts.length; x++) {
print("byte[" + x + "] = " + getBts[x]);
}
// 将基本数据类型转成字符串。static String valueOf(数据类型)
// 3+"";//String.valueOf(3);
String num = String.valueOf(2);
print("num: " + num);
}
/*
* 替换
*/
private static void method_replace(String str) {
// 如果要替换的字符不存在，返回的还是原串。
String newStr = str.replace('a', 'm');// 替换掉所有的该字符
print(str);
print(newStr);
String newSt = str.replace("asd", "qqq");
print(str);
print(newSt);
}
/*
* 切割
*/
private static void method_split(String str) {
// String[] split(regex);
String[] strs = str.split("s");
for (int x = 0; x < strs.length; x++) {
print("String[" + x + "] = " + strs[x]);
}
}
/*
* 获取字符串中的一部分
*/
private static void method_sub(String str) {
print(str.substring(2));// 从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
print(str.substring(2, 4));// 包含头，不包含尾。s.substring(0,s.length());
}
/*
* 转换，去除空格，比较。
*/
private static void method_change() {
String s = " Hello Java ";
print(s.toLowerCase());// 转小写
print(s.toUpperCase());// 转大写
print(s.trim());// 去空格
// 对两个字符串进行自然顺序的比较
String s1 = "aaa";
String s2 = "aaa";
print(s1.compareTo(s2));// 大于返回正数，小于返回负数，相等返回0
}
private static void print(Object obj) {
System.out.println(obj);
}
}再说说字符串中的比较，这是很容易混淆的。String类的equals方法比较的是字符串中的内容是否相同，而“==”在对象中比较的是内存地址是否相同。
String a = "abc";
String b = "abc";
String c = new String("abc");
String d = new String("abc");
System.out.println(a==b);//true
System.out.println(a==c);//false
System.out.println("a.equals(c):" + a.equals(c));//true
System.out.println("d.equals(c):" + d.equals(c));//true
System.out.println(d==c);//false这里贴上点练习题：
/*
1，模拟一个trim方法，去除字符串两端的空格。
思路：
1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
*/
public class TrimTest {
public static void main(String[] args) {
String a = " shs aasn ";
a = trimTest(a);
System.out.println(a);
}
private static String trimTest(String str) {
int start = 0;
int end = str.length() - 1;
while (start <= end && str.charAt(start) == ' ') {
start++;
}
while (start <= end && str.charAt(end) == ' ') {
end--;
}
return str.substring(start, end + 1);
}
}/*
* /练习二：将字符串反转。
/*
思路：
1，将字符串变成数组。
2，对数组反转。
3，将数组变成字符串。
*/
public class ReverseString {
public static void main(String[] args) {
String str = "shag klh";
String out = reverseString(str);
System.out.println(out);
}
/*
* 将字符串反转
*/
private static String reverseString(String str) {
// 将字符串变成数组
char[] chs = str.toCharArray();
// 将数组反正，也就是收尾调换
reverseArray(chs);
return new String(chs);
}
private static void reverseArray(char[] chs) {
char temp;
for (int start = 0, end = chs.length - 1; start < end; start++, end--) {
temp = chs[start];
chs[start] = chs[end];
chs[end] = temp;
}
}
}/*
* 3，获取一个字符串在另一个字符串中出现的次数。
"abkkcdkkefkkskk"
思路：
1，定义个计数器。
2，获取kk第一次出现的位置。
3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
每获取一次就计数一次。
4，当获取不到时，计数完成。
*/
public class GetsubCount {
public static void main(String[] args) {
String str = "abkkcdkkefkkskk";
System.out.println(getSubCount(str, "kk"));
}
private static int getSubCount(String str, String key) {
int count = 0;
int index = 0;
while ((index = str.indexOf(key, index)) != -1) {
index = index + key.length();
count++;
}
return count;
}
}public class GetMaxContainsString {
public static void main(String[] args) {
String s1 = "asdfghjkklaksjd";
String s2 = "aswasdksgdh";
print(GetMaxConStr(s1,s2));
}
private static String GetMaxConStr(String s1,String s2){
String max = "";
String min = "";
max = (s1.length() > s2.length())? s1: s2;
min = (max == s1)? s2: s1;
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);
//print(temp);
if(max.contains(temp)){
return temp;
}
}
}
return "-1";
}
private static void print(Object obj){
System.out.println(obj);
}
}
第二 StringBuffer
一、概述：StringBuffer是字符串缓冲区。是一个容器。
二、特点：
1、长度是可变化的。
2、可以直接操作多个数据类型。
3、最终会通过toString方法变成字符串。
三、常见操作：
1、存储。
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。不支持byte和char，需要对其进行转换才能操作。
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(start,end,string);
void setCharAt(int index, char ch) ;
5、反转。
StringBuffer reverse();
6、将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)//第一个参数是说StringBuffer 从哪开始取值，第二个就是在哪结束啦，第三个参数是插入到哪个数据，第四个是说从数组中的哪个索引开始插入。
特别说明：
JDK1.5 版本之后出现了StringBuilder.stringbuilder和stringbuffer用法相同
StringBuffer是线程同步。
StringBuilder是线程不同步。
以后开发，建议使用StringBuilder，因为既然stringbuilder是后面才出来的也就是说是升级得来的，升级一般都是围绕提高效率。简化书写。提高安全性。来展开的，而此处则是提高效率。
第三 包装类
一、概述：
1、有时候，需要将int这样的基本类型转换为对象，以便可以使用一些方法。所有的基本类型都有一个相对应的类。这些类就称之为包装类。
2、基本数据类型对应的包装类：
基本数据类型 引用数据类型（包装类）
byte Byte
short Short
int Integeter
long Long
float Float
double Double
boolean Boolean
char Character
二、常见操作：
用于基本数据类型和字符串类型间的转换
1、转换：
1）基本数据类型转换为字符串
基本数据类型 + "" ---> 直接转换成字符串
基本数据类型.toString(基本数据类型值) ---> 如：Integer.toString(34);//将整数34变为"34"
2）字符串转换为基本数据类型：
基本数据类型名 变量名 = 包装类名.pase包装类名(String)
如：int a = Integer.paseInt("123");//结果为123
2、转二进制：
Integer.toBinaryString(int a);
十进制 -----> 其他进制
1）转为二进制：toBinaryString();
2）转为八进制：toOctalString();
3）转为十六进制：toHexString();
其他进制 -----> 十进制
parseInt(String,radix);//radix指的是相对应的进制数
class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//整数类型的最大值。
//sop("int max :"+Integer.MAX_VALUE);
// 将一个字符串转成整数。
int num = Integer.parseInt("123");//必须传入数字格式的字符串。
//long x = Long.parseLong("123");
// sop("num="+(num+4));
// sop(Integer.toBinaryString(-6));
// sop(Integer.toHexString(60));
int x = Integer.parseInt("3c",16);
sop("x="+x);
}class IntegerDemo1
{
public static void main(String[] args)
{
// Integer x = new Integer(4);
Integer x = 4;//自动装箱。//new Integer(4)
x = x/* x.intValue() */ + 2;//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范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。
}
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);
}
}
扫一扫
78
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
