------- android培训、java培训、期待与您交流！ ----------
1. String类
String类是用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。1-1 常见的操作
以下字符串的操作方法每个都要牢记，都是常用方法，不记牢对不起观众
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在字符串中出现的位置。
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);
大多数方法的示例：
import java.lang.String.*;
class StringDemo
{
public static void main(String[] args)
{
Method10();
}
public static String Method1()
{
String s = "abcd";
return s.toUpperCase();//将字符串转换成大写，相应的，转换为小写的方法是toLowerCase();
}
public static char Method2()
{
String s = "abcd";
return s.charAt(2);//返回指定索引处的 char 值
}
public static int Method3()
{
String s1 = "abcd";
String s2 = "acfder";
String s3 = "ab";
return s1.compareTo(s2);
/*按Unicode值的顺序比较字符串大小，前者减后者
return s1.compareTo(s3);
按照顺序没有不同则比较长度，前者减后者
compareToIgnoreCase(String str)
按字典顺序比较两个字符串，不考虑大小写。*/
}
public static String Method4()
{
String s1 = "nishi";
String s2 = "shabi";
return s1.concat(s2);//将指定字符串连接到此字符串的结尾
}
public static int Method5()
{
String s1 = "nasdihfw224nak";
return s1.indexOf('a');//返回指定字符在此字符串中第一次出现处的索引
//s1.indexOf('a',4);//返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
//s1.indexOf("na");//返回指定子字符串在此字符串中第一次出现处的索引
//s1.indexOf("na",2);//返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
//同样的四种方法，还有倒着进行的四种，lastIndexOf（）；
}
public static boolean Method6()
{
String s1 = "nihaoahello";
String s2 = "hello";
return s1.contains(s2);
}
public static boolean Method7()
{
String s = "hello.java";
return s.startsWith("hello");
}
public static boolean Method8()
{
String s = "hello.java";
return s.endsWith(".java");
}
public static boolean Method9()
{
String s1 = "hello.java";
String s2 = new String("hello.java");//这里有两个对象，new是一个、“”又是一个，因此与s1不相等
String s3 = "hello.java";//字符串一经建立，就放在常量池中，第二次建立相同的字符串，并不会新建，而是引用已存在的对象
s1.equals(s3);//判断内容是否相同；还有一个忽略大小写的方法boolean equalsIgnoreCase();
return s1 == s2;//s1与s2不相等，与s3相等
}
public static void Method10()
{
char[] arr = {'a','b','c','d','e','f'};
String s1 = new String(arr);
String s2 = new String(arr,1,3);
String s3 = String.copyValueOf(arr);
String s4 = String.copyValueOf(arr,1,3);
String s5 = String.valueOf(arr);
String s6 = String.valueOf(arr,1,3);
sop("s1="+s1);
sop("s2="+s2);
sop(" ");
sop("s3="+s3);
sop("s4="+s4);
sop(" ");
sop("s5="+s5);
sop("s6="+s6);
String s7 = "zxcvbnm";
char[] chs = s7.toCharArray();
for(int x=0; x<chs.length; x++)
{
sop("ch="+chs[x]);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}1-2 相关练习
练习一：
/*1，模拟一个trim方法，去除字符串两端的空格。
思路：
1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串
*/
class StringTest
{
public static void main(String[] args)
{
String s = " ni shi ";
myTrim1(s);
myTrim2(s);
}
public static void myTrim1(String s)
{
int start = 0;
int end = s.length()-1;
int count1 = 0;
int count2 = 0;
for (start=0; s.charAt(start)==' ' && start<=end; start++)
{
count1++; //按照for循环顺序，count先自增，start再自增，因此start与count相等
}
for (end=s.length()-1; s.charAt(end)==' ' && start<=end; end--)
{
count2 = end; //count比最终end的结果大1，正好下面substring中不需要加一
}
String s2 = s.substring(count1,count2);
System.out.println(s2.length());
System.out.println(s2);
}
public static void myTrim2(String str)
{
int start = 0,end = str.length()-1;
while(start<=end && str.charAt(start)==' ')
start++;
while(start<=end && str.charAt(end)==' ')
end--;
String s2 = str.substring(start,end+1);
System.out.println(s2.length());
System.out.println(s2);
}
}
/*2，将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
思路：
1，曾经学习过对数组的元素进行反转。
2，将字符串变成数组，对数组反转。
3，将反转后的数组变成字符串。
4，只要将或反转的部分的开始和结束位置作为参数传递即可。
*/
class StringTest1
{
public static void main(String[] args)
{
String s = "abcdefg";
char[] arr = s.toCharArray();
int start = 0;
int end = s.length()-1;
for (int i=0; i<arr.length; i++)
{
System.out.print(arr[i]);
}
reverse(arr,start,end);
System.out.println("翻转后");
for (int i=0; i<arr.length; i++)
{
System.out.print(arr[i]);
}
}
public static void reverse(char[] arr,int start,int end)
{
while (start < end)
{
char temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
}
/*3，获取一个字符串在另一个字符串中出现的次数。
"abkkcdkkefkkskk"
*/
class StringTest2
{
public static void main(String[] args)
{
String s = "abkkcdkkefkkskk";
String key = "kk";
int count = indexCount(s,key);
System.out.println(count);
}
public static int indexCount(String s,String key)
{
int index = 0;
int count = 0;
while ((index = s.indexOf(key,index)) != -1)
{
index = index + key.length();
count++;
}
return count;
}
}
/*
4，获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
"abcwerthelloyuiodef"
"cvhellobnm"
思路：
1，将短的那个子串按照长度递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含，
如果包含，已经找到！。
*/
class StringTest3
{
public static void main(String[] args)
{
String s1 = "abcwerthelloyuiodef";
String s2 = "cvhellobnm";
System.out.println(contain(s1,s2));
}
public static String contain(String s1,String s2)
{
for (int i=0; i<s2.length(); i++)
{
for(int j=0,k=s2.length()-i; k!=s2.length()+1; j++,k++)
{
String temp = s2.substring(j,k);
if (s1.contains(temp))
{
return temp;
}
}
}
return "";
}
}
2. StringBuffer和StringBuilder
2-1 StringBuffer类
StringBuffer是字符串缓冲区，是一个容器。
特点：
1，长度是可变化的。
2，可以字节操作多个数据类型。
3，最终会通过toString方法变成字符串。
C create U update R read D delete
2-1-1 常见操作
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(start,end,string);
void setCharAt(int index, char ch) ;
5，反转。
StringBuffer reverse();
6，
将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
2-1-2 代码示例
class StringBufferDemo
{
public static void main(String[] args)
{
//method_update();
StringBuilder sb = new StringBuilder("abcdef");
char[] chs = new char[6];
sb.getChars(1,4,chs,1);//将
for(int x=0; x<chs.length; x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
draw(3,6);
draw(8,9);
// StringBuilder sb1 = new StringBuilder();
// sb1.append(new Demo()).append(new Demo());
// sop("sb1="+sb1);
}
public static void method_update()
{
StringBuffer sb = new StringBuffer("abcde");
// sb.replace(1,4,"java");
sb.setCharAt(2,'k');
sop(sb.toString());
}
public static void method_del()
{
StringBuffer sb = new StringBuffer("abcde");
// sb.delete(1,3);
//清空缓冲区。
//sb.delete(0,sb.length());
//sb.delete(2,3);
sb.deleteCharAt(2);
sop(sb.toString());
}
public static void method_add()
{
StringBuffer sb = new StringBuffer();
//sb.append("abc").append(true).append(34);
// StringBuffer sb1 = sb.append(34);
// sop("sb==sb1:"+(sb==sb1));
sb.insert(1,"qq");
sop(sb.toString());//abctrue34
//sop(sb1.toString());
}
public static void sop(String str)
{
System.out.println(str);
}
public static void draw(int row,int col)
{
StringBuilder sb = new StringBuilder();
for(int x=0; x<row; x++)
{
for(int y=0; y<col; y++)
{
sb.append("*");
}
sb.append("\r\n");
}
sop(sb.toString());
}
}<span style="font-family: 'Microsoft YaHei'; background-color: rgb(255, 255, 255);"> </span>2-2 StringBuilder类
JDK1.5 版本之后出现了StringBuilder.与StringBuffer方法相同
两者区别：
StringBuffer是线程同步。
StringBuilder是线程不同步。
以后开发，建议使用StringBuilder
升级三个因素：
1，提高效率。
2，简化书写。
3，提高安全性。
3. Integer类
Integer类是int型数据包装类
3-1 Integer和int的区别
先看代码：
package com.test;
/**
*
* @author user
*
*/
public class TestInteger {
/**
* @param args
*/
public static void main(String[] args) {
int i = 128;
Integer i2 = 128;
Integer i3 = new Integer(128);
//Integer会自动拆箱为int，所以为true
System.out.println(i == i2);
System.out.println(i == i3);
System.out.println("**************");
Integer i5 = 127;//java在编译的时候,被翻译成-> Integer i5 = Integer.valueOf(127);
Integer i6 = 127;
System.out.println(i5 == i6);//true
/*Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);//false
*/ Integer ii5 = new Integer(127);
System.out.println(i5 == ii5); //false
Integer i7 = new Integer(128);
Integer i8 = new Integer(123);
System.out.println(i7 == i8); //false
}
} 首先，17行和18行输出结果都为true,因为Integer和int比都会自动拆箱（jdk1.5以上）。
22行的结果为true,而25行则为false,很多人都不动为什么。其实java在编译Integer i5 = 127的时候,被翻译成-> Integer i5 = Integer.valueOf(127);所以关键就是看valueOf()函数了。只要看看valueOf()函数的源码就会明白了。
JDK源码的valueOf函数式这样的：
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}对于27行和30行，因为对象不一样，所以为false。
我对于以上的情况总结如下：
①无论如何，Integer与new Integer不会相等。不会经历拆箱过程，i3的引用指向堆，而i4指向专门存放他的内存（常量池），他们的内存地址不一样，所以为false
②两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false
java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存
③两个都是new出来的,都为false
④int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比。
3-2 基本数据类型对象包装类
byteByte
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
3-2-1 基本数据类型包装类常见作用
基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换。（1）基本数据类型转成字符串。
基本数据类型+""
基本数据类型.toString(基本数据类型值);
如： Integer.toString(34);//将34整数变成"34";
（2）字符串转成基本数据类型。
xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
Integer i = new Integer("123");
int num = i.intValue();
（3）十进制转成其他进制。
toBinaryString();
toHexString();
toOctalString();
（4）其他进制转成十进制。
parseInt(string,radix);
1424
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
