------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流!
Java常用API整理
A.(面试题) 字符串最大特点:一旦被初始化就不可以被改变。
指的是字符串在常量池中的值不可改变,但是指向该字符串的引用是可以改变的,也就是说这个引用可以改变后指向别的字符串。
eg. String str = "abcd";
str+="efgh";
System.out.println(str);//输出结果为abcdefgh
解释:1."abcd"这个内容在常量池中,不可改变;2."efgh"也在常量池中开辟一个空间,也不可改变;3.再开辟一个空间,存放"abcdefgh",然后指向"abcd"的引用指向了"abcdefgh".
===>另一种类型题(面试题):
基本类型:形式参数改变不影响实际参数;
引用类型:形式参数改变直接影响实际参数。
但是,String是一种特殊的引用类型,它的形式参数的改变不影响实际参数
eg.
public class Test {
public static void main(String[] args) {
String s = "abc";
change(s);
System.out.println(s);//abc
}
public static void change(String s){
s+="hello";
System.out.println(s);//abchello
}
}
B.(面试题)
class StringDemo
{
public static void main(String[] args)
{
String s1 = "abc";//s1是一个类类型变量,"abc"是一个对象。
String s2 = new String("abc");//s1和s2有什么区别?s1在内存中有一个对象,s2在内存中有两个对象。
}
}
String str = new String("abc");和 String str ="abc";有什么区别吗?
有区别。前者在内存中有两个内存空间,后者只有一个。原因是前者创建对象在堆内存中开辟了一个空间,然后又在常量池中给"abc"开辟了一个空间,对象引用指向堆内存,堆内存指向常量池;后者只在常量池中开辟一个空间存储"abc",没有再堆内存中开辟空间。
===>与之类似的题目(面试题):常量相加会直接累加,然后在常量池里面去找有没有,如果有,就是常量池里面的值,不会再开辟新的空间存储;
而变量则会开辟新的空间。
eg.
public class Test {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 ="ab";
System.out.println(s3==s1+s2);//false s1+s2相当于在堆中创建了一个新的字符串,指向"ab"
System.out.println(s3=="a"+"b");//true
}
}
关于null和””说法正确的是( ABD )
a) null是常量
b) “”是字符串对象
c) null可以调用方法 不可以,空指针异常
d) “”可以调用方法
-----------------------------------------------------------------
String类适用于描述字符串事物,那么它就提供了多个方法对字符串进行操作。
常见操作:"abcd"
1.构造方法:
A.String():
初始化一个新创建的 String 对象,使其表示一个空字符序列。
B.String(byte[] bytes) :
将字节数组转为字符串,注意此时将byte型数字转换为了ASC码中对应的字符,下面的构造方法同理。
C.String(byte[] bytes, int offset, int length):
将字节数组的offset位置开始,长度为length的部分截取为字符串。
D.String(char[] value):
将字符数组转换为字符串。
E.String(char[] value, int offset, int length):
将字符数组的offset位置开始,长度为length的部分截取为字符串。
F.String(String original):
创建字符串original的副本。
G.最简单的赋值方法:
如:String s = "abcdf";,这时s依然是一个对象。
2.成员方法:
(1).获取:
1.1 字符串中包含的字符数,也就是字符串的长度。
int length():获取长度
注意与数组中的区别,数组那是属性length,如array.length ,而这里是方法,应为arr.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在字符串中第一次出现的位置(类似数组,是从0开始往后计算的)
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
String s = "";//isEmpty() true
String s = 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 copyVlaueOf(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)//把int类型基本数据转换成字符串。
static String valueOf(double)
//3+"";//String.valueOf(3);
特殊:字符串和字节数组在转换过程中,是可以指定编码表的
注意:参数类型可以是Object,所以可以接收任意类型的
3.6 String concat(String str):
将指定字符串连接到此字符串的结尾。
(4).替换:
String replace(char oldChar, char newChar)
用新字符去替换字符串中指定的旧字符
String replace(String oldString,String newString)
用新字符串去替换字符串中指定的旧字符串
(5).切割:
String[] split(String regex)
以regex字符串为标记进行切割,并将切割后的各个子字符串存入String型数组中。
(6).子串:获取字符串的一部分
String subString(begin);//(包括此指定位置)[begin,到最后
String subString(begin,end);//(包左不包右)[begin,end)
(7).转换,去空格,比较
7.1 将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除
String trim();
7.3 对两个字符串进行自然顺序的比较
int compareTo(String anotherString)
按字典顺序比较两个字符串(注:两个字符串收个不相同的字符之差)。
eg. String s1 = "abcd";
String s2 = "abcd";
String s3 = "abce";
System.out.println(s1.compareTo(s2));//0
System.out.println(s1.compareTo(s3));//-1
int compareToIgnoreCase(String str)
按字典顺序比较两个字符串,不考虑大小写。
Demo:
StringMethodDemo.java
Test1:模拟登录:给三次机会,并提示还有几次
StringTest1.java
Test2:统计数据:给一个字符串,如"HelloWorld12345",统计大写字母、小写字母、数字的个数
StringTest2.java
Test3:需求 : 把字符串的首字母转成大写,其余为小写
StringTest3.java
Test4:需求:设计一个方法,用于获取一个字符串中指定子串出现的次数。
比如说"hanbasdnbafllgnbahjnbakqqqqlnbaxi" 在这个字符串中,有多少个nba?
获取一个字符串中指定字串出现的次数.jpg
StringTest4.java
小总结:
字符串转成字符数组:String s ="asdfg";
char[] chs = s.toCharArray();
字符数组转成字符串:char[] arr = {'a','s','d','f','g'};
String s = new String(arr);
特点:
1.长度是可变化的
2.可以直接操作多个数据类型
3.最终会通过toString方法变成字符串
StringBuffer是线程安全的
1.StringBuffer与String区别?
String一旦被赋值,值不能再改变;而StringBuffer,值还可以改变。
原因:
StringBuufer采用的是缓冲区机制。一开始,首先开辟一些空间,然后,随着数据的增多,还可以继续开辟空间,这些操作针对的是同一个对象。
===>赋值运算之后值变不变的问题?
String:形参的改变不影响它;
StringBuffer:形参的改变影响它;
eg.public class Test {
public static void main(String[] args) {
StringBuffer sb =new StringBuffer("abc");
System.out.println(Test.change(sb));
}
public static StringBuffer change(StringBuffer sb){
return sb.append("def");
}
}
运行结果是:abcdef
2.构造方法:
StringBuffer()
初始容量为16个字符(不是字节!)
StringBuffer(int capacity)
指定初始容量的字符串缓冲区(指定之后就不再有那个默认的16字符的空间)。
StringBuffer(String str)
构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容(这时会在后面默认加上16个字符空间)。
可以通过此构造方法实现String和StringBuffer之间的转换。
3.成员方法:
CURT create update read delete
1.存储
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。(任意类型数据)
注意:操作的是同一个StringBuffer
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()//字符个数,实际长度。
int capacity()字符容量,理论长度。
String subString(int satrt,int end)
4.修改
StringBuffer replace(satrt,end,String);
void setCharAt(int index,char ch);
5.反转
StringBuffer reserve();
6. 返回此序列中数据的字符串表示形式。
String toString()
JDK1.5版本之后出现了StringBuilder
StringBuffer是线程同步的,StringBuilder是线程不同步的
以后开发,建议使用StringBuilder
升级三个因素:
1.提高效率
2.简化书写
3.提高安全性
8个基本数据类型:
byte Byte
short Shaort
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
该包装对象主要用于基本数据类型和字符串之间的转换。
基本数据类型 ---> 字符串:
1.基本数据类型+""
2.用String类中的静态方法alueOf(基本数据类型值);
基本数据类型.toString(基本数据类型值);
如:Integer.toString(34);//将34整数变为"34"
字符串 ---> 基本数据类型
1. xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");
double d = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
只有Character没有parse方法
2.如果字符串被Integer进行了对象的封装,可以使用intValue();
讲一个Integer对象转成基本数据类型值
十进制 ---> 其他进制:
toBinaryString();
toHexString();
toOctalString();
其他进制 ---> 十进制
parseInt(string,index);
基本数据类型包装类新特性:JDK1.5之后 自动装箱拆箱 简化书写
Integer i = 4;//i = new Integer(4);
i= i+6;//i = new Integer(i.intValue() + 6);
Integer i = null;//当值为null时调用intValue方法会出现异常
Integer a = new Integer(127);
Integer b = new Integer(127);
System.out.println(a==b);//false
System.out.println(a.equals(b));//true
Integer x = 127;
Integer y = 127;
System.out.println(x==y);//true JDK1.5以后,自动装箱,如果装的是一个字节,那么还数据会被共享不会重新开辟空间
System.out.println(x.equals(y));//true
Integer a = new Integer(128);
Integer b = new Integer(128);
System.out.println(a==b);//false
System.out.println(a.equals(b));//true
Integer x = 128;
Integer y = 128;
System.out.println(x==y);//false
System.out.println(x.equals(y));//true
Integer类(重点)
1.字段:如 static int MAX_VALUE
它表示 int 类型能够表示的最大值。
static int MIN_VALUE
它表示 int 类型能够表示的最小值。
2.构造方法:
A.Integer(int value)
构造一个新分配的 Integer 对象,将int类型的value变成Integer类型的。
eg. int num=100;
Integer i =new Integer(num);
System.out.println(i); //100
===>JDK5.0之后的新特性:
a.自动装箱,也就是把基本类型直接复制给引用类型。
eg.Integer i = 100;
b.自动拆箱,也就是把引用类型直接拆成基本类型。
eg. Integer i = 100;
i = i+200;//先拆箱后装箱
==>但是要注意对i进行不为null判断,当i为null时,会报指针异常。
B.Integer(String s)
构造一个新分配的 Integer 对象,将String类型的s变成Integer类型的,这里的s只能是数字形式的字符串,不能含有非数字字符。
eg. String s = "1";
Integer ii = new Integer(s);
System.out.println(s);//1
3.成员方法:
A.进制转换
static String toBinaryString(int i)
以二进制(基数 2)无符号整数形式返回一个整数参数的字符串表示形式。
static String toHexString(int i)
以十六进制(基数 16)无符号整数形式返回一个整数参数的字符串表示形式。
static String toOctalString(int i)
以八进制(基数 8)无符号整数形式返回一个整数参数的字符串表示形式。
eg.
System.out.println(Integer.toBinaryString(60));//111100
B.int类型数据与String类型的数据之间的相互转换:
推荐方法:
int--->String
1)String.valueOf(int i)
2)Integer.toString(int i)
String --int
Integer.parseInt(String s)
public class StringAndInt {
public static void main(String[] args) {
int num = 100;
//int--->String
//方式一:开发常见,但是不专业
String s1 = num+"";
//方式二(推荐):String的静态方法:public static String valueOf(int i)
String s2 = String.valueOf(num);
//方式三:int--Integer--String
Integer i = new Integer(num);
String s3 =i.toString();
//方式四(推荐):Integer的静态方法:public static String toString(int i)
String s4 = Integer.toString(num);
//String--->int
String s = "100";//注意这里的s只能是数字形式的字符串!
//方式一:String--Integer--int
//调用Integer的 public int intValue()
Integer ii= new Integer(s);
int num2 = ii.intValue();
//方式二(推荐):调用Integer的静态方法 public static int parseInt(String s)
int num3 = Integer.parseInt(s);
}
}
4.byte常量池(面试题)
2.重要方法:
A.tostring():用于输出对象地址值。
eg.
public class StudentTest
{
public static void main(String[] args)
{
Student s = new Student();
System.out.println(s);//此句与下面那句是等效的
System.out.println(s.toString());
}
}
打印结果:Object.Student@1833eca
Object.Student@1833eca
注:1.用输出语句直接输出对象的名称,其实底层调用了该对象的toString()方法;
2.为了让对象的显示有意义,一般Object的子类都重写了该方法。
B.equals():用于比较对象是否相等,比较的是地址值;而一般来说,同一个类的不同对象,地址值肯定不一样,
Object类的equals()方法的默认操作是没有意义的。所以,我们一般会根据需求重写此方法,如用于比较
类的成员变量值是否相等。
a.重写equals()一般就是为了比较某个类的多个对象的所有成员变量值是否相等
如果成员变量是基本类型,就用==比较;
如果成员变量是引用类型,就用该变量所对应的数据类型的equals()方法比较。
eg.Student类中比较成员变量的函数:
public boolean equals(Object obj)//参数Object类型的,也就是说任何类型的对象都可以传入(向上默认自动转型)
{
if(this==obj)//为了提高代码效率,对传入的对象做一个是否是自己的判断。
{
return true;
}
if(!(obj instanceof Student))//为提高代码健壮性,对传入对象做一个是否为Student类型的判断;
{
return false;
}
Student s = (Student) obj;//向下转型
return this.age==s.age && this.name.equals(s.name);
}//这里this.name是String类型,则其调用的就是String类的equals()方法。
DateFormat的子类。
1.构造方法:
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat的对象。
常用的两种用法:
1)从Date类型向String类型转;
public final String format(Date date)//这个方法存在于其父类DateFormat中,其内并没有重写,所以找的时候在DateFormat中找。
常见日期模式:
yyyy年MM月dd日 HH:mm:ss
yyyy年MM月dd日
HH:mm:ss
yyyy-MM-dd HH:mm:ss
……
eg.
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatTest {
public static void main(String[] args) {
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String str = sdf.format(d);
System.out.println(str);
}
}
结果:2014年09月25日 22:38:23
2)从String类型向Date转。
Date parse(String source)//这个方法存在于其父类DateFormat中,其内并没有重写,所以找的时候在DateFormat中找。
从给定字符串的开始解析文本,以生成一个日期。
注意点:如果是字符串到日期的转换,自己指定的日期模式必须与字符串的格式相同。
eg.
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatTest2 {
public static void main(String[] args) throws ParseException {
String s ="2014-09-24 11:30:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//必须与s的格式一样!
Date d = sdf.parse(s);
System.out.println(d);
}
}
===>如果给了你一个格式的String,让你输出另一个格式的Date。
思路:String==>转成同形式的Date==>转换成另一种形式的String并输出。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatTest2 {
public static void main(String[] args) throws ParseException {
String s ="2014-09-24 11:30:00"; //给的是这个形式的String
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date d = sdf.parse(s); //换成上述形式的Date
SimpleDateFormat sdf2 = new SimpleDateFormat("dd-MM-yyyy");
String s2 = sdf2.format(d); //再把上边的Date换成所要的形式的String
System.out.println(s2);
}
}
输出:24-09-2014
Java常用API整理
一、String
重点问题:A.(面试题) 字符串最大特点:一旦被初始化就不可以被改变。
指的是字符串在常量池中的值不可改变,但是指向该字符串的引用是可以改变的,也就是说这个引用可以改变后指向别的字符串。
eg. String str = "abcd";
str+="efgh";
System.out.println(str);//输出结果为abcdefgh
解释:1."abcd"这个内容在常量池中,不可改变;2."efgh"也在常量池中开辟一个空间,也不可改变;3.再开辟一个空间,存放"abcdefgh",然后指向"abcd"的引用指向了"abcdefgh".
===>另一种类型题(面试题):
基本类型:形式参数改变不影响实际参数;
引用类型:形式参数改变直接影响实际参数。
但是,String是一种特殊的引用类型,它的形式参数的改变不影响实际参数
eg.
public class Test {
public static void main(String[] args) {
String s = "abc";
change(s);
System.out.println(s);//abc
}
public static void change(String s){
s+="hello";
System.out.println(s);//abchello
}
}
B.(面试题)
class StringDemo
{
public static void main(String[] args)
{
String s1 = "abc";//s1是一个类类型变量,"abc"是一个对象。
String s2 = new String("abc");//s1和s2有什么区别?s1在内存中有一个对象,s2在内存中有两个对象。
}
}
String str = new String("abc");和 String str ="abc";有什么区别吗?
有区别。前者在内存中有两个内存空间,后者只有一个。原因是前者创建对象在堆内存中开辟了一个空间,然后又在常量池中给"abc"开辟了一个空间,对象引用指向堆内存,堆内存指向常量池;后者只在常量池中开辟一个空间存储"abc",没有再堆内存中开辟空间。
===>与之类似的题目(面试题):常量相加会直接累加,然后在常量池里面去找有没有,如果有,就是常量池里面的值,不会再开辟新的空间存储;
而变量则会开辟新的空间。
eg.
public class Test {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 ="ab";
System.out.println(s3==s1+s2);//false s1+s2相当于在堆中创建了一个新的字符串,指向"ab"
System.out.println(s3=="a"+"b");//true
}
}
关于null和””说法正确的是( ABD )
a) null是常量
b) “”是字符串对象
c) null可以调用方法 不可以,空指针异常
d) “”可以调用方法
-----------------------------------------------------------------
String类适用于描述字符串事物,那么它就提供了多个方法对字符串进行操作。
常见操作:"abcd"
1.构造方法:
A.String():
初始化一个新创建的 String 对象,使其表示一个空字符序列。
B.String(byte[] bytes) :
将字节数组转为字符串,注意此时将byte型数字转换为了ASC码中对应的字符,下面的构造方法同理。
C.String(byte[] bytes, int offset, int length):
将字节数组的offset位置开始,长度为length的部分截取为字符串。
D.String(char[] value):
将字符数组转换为字符串。
E.String(char[] value, int offset, int length):
将字符数组的offset位置开始,长度为length的部分截取为字符串。
F.String(String original):
创建字符串original的副本。
G.最简单的赋值方法:
如:String s = "abcdf";,这时s依然是一个对象。
2.成员方法:
(1).获取:
1.1 字符串中包含的字符数,也就是字符串的长度。
int length():获取长度
注意与数组中的区别,数组那是属性length,如array.length ,而这里是方法,应为arr.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在字符串中第一次出现的位置(类似数组,是从0开始往后计算的)
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
String s = "";//isEmpty() true
String s = 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 copyVlaueOf(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)//把int类型基本数据转换成字符串。
static String valueOf(double)
//3+"";//String.valueOf(3);
特殊:字符串和字节数组在转换过程中,是可以指定编码表的
注意:参数类型可以是Object,所以可以接收任意类型的
3.6 String concat(String str):
将指定字符串连接到此字符串的结尾。
(4).替换:
String replace(char oldChar, char newChar)
用新字符去替换字符串中指定的旧字符
String replace(String oldString,String newString)
用新字符串去替换字符串中指定的旧字符串
(5).切割:
String[] split(String regex)
以regex字符串为标记进行切割,并将切割后的各个子字符串存入String型数组中。
(6).子串:获取字符串的一部分
String subString(begin);//(包括此指定位置)[begin,到最后
String subString(begin,end);//(包左不包右)[begin,end)
(7).转换,去空格,比较
7.1 将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除
String trim();
7.3 对两个字符串进行自然顺序的比较
int compareTo(String anotherString)
按字典顺序比较两个字符串(注:两个字符串收个不相同的字符之差)。
eg. String s1 = "abcd";
String s2 = "abcd";
String s3 = "abce";
System.out.println(s1.compareTo(s2));//0
System.out.println(s1.compareTo(s3));//-1
int compareToIgnoreCase(String str)
按字典顺序比较两个字符串,不考虑大小写。
Demo:
StringMethodDemo.java
Test1:模拟登录:给三次机会,并提示还有几次
StringTest1.java
Test2:统计数据:给一个字符串,如"HelloWorld12345",统计大写字母、小写字母、数字的个数
StringTest2.java
Test3:需求 : 把字符串的首字母转成大写,其余为小写
StringTest3.java
Test4:需求:设计一个方法,用于获取一个字符串中指定子串出现的次数。
比如说"hanbasdnbafllgnbahjnbakqqqqlnbaxi" 在这个字符串中,有多少个nba?
获取一个字符串中指定字串出现的次数.jpg
StringTest4.java
小总结:
字符串转成字符数组:String s ="asdfg";
char[] chs = s.toCharArray();
字符数组转成字符串:char[] arr = {'a','s','d','f','g'};
String s = new String(arr);
二、StringBuffer
StringBuffer是字符串缓冲区,是一个容器。字符串缓冲区是为了提高字符串的操作效率特点:
1.长度是可变化的
2.可以直接操作多个数据类型
3.最终会通过toString方法变成字符串
StringBuffer是线程安全的
1.StringBuffer与String区别?
String一旦被赋值,值不能再改变;而StringBuffer,值还可以改变。
原因:
StringBuufer采用的是缓冲区机制。一开始,首先开辟一些空间,然后,随着数据的增多,还可以继续开辟空间,这些操作针对的是同一个对象。
===>赋值运算之后值变不变的问题?
String:形参的改变不影响它;
StringBuffer:形参的改变影响它;
eg.public class Test {
public static void main(String[] args) {
StringBuffer sb =new StringBuffer("abc");
System.out.println(Test.change(sb));
}
public static StringBuffer change(StringBuffer sb){
return sb.append("def");
}
}
运行结果是:abcdef
2.构造方法:
StringBuffer()
初始容量为16个字符(不是字节!)
StringBuffer(int capacity)
指定初始容量的字符串缓冲区(指定之后就不再有那个默认的16字符的空间)。
StringBuffer(String str)
构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容(这时会在后面默认加上16个字符空间)。
可以通过此构造方法实现String和StringBuffer之间的转换。
3.成员方法:
CURT create update read delete
1.存储
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。(任意类型数据)
注意:操作的是同一个StringBuffer
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()//字符个数,实际长度。
int capacity()字符容量,理论长度。
String subString(int satrt,int end)
4.修改
StringBuffer replace(satrt,end,String);
void setCharAt(int index,char ch);
5.反转
StringBuffer reserve();
6. 返回此序列中数据的字符串表示形式。
String toString()
JDK1.5版本之后出现了StringBuilder
StringBuffer是线程同步的,StringBuilder是线程不同步的
以后开发,建议使用StringBuilder
升级三个因素:
1.提高效率
2.简化书写
3.提高安全性
三、基本数据类型对象包装类
基本数据类型对象包装类:为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为。丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。8个基本数据类型:
byte Byte
short Shaort
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
该包装对象主要用于基本数据类型和字符串之间的转换。
基本数据类型 ---> 字符串:
1.基本数据类型+""
2.用String类中的静态方法alueOf(基本数据类型值);
基本数据类型.toString(基本数据类型值);
如:Integer.toString(34);//将34整数变为"34"
字符串 ---> 基本数据类型
1. xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");
double d = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
只有Character没有parse方法
2.如果字符串被Integer进行了对象的封装,可以使用intValue();
讲一个Integer对象转成基本数据类型值
十进制 ---> 其他进制:
toBinaryString();
toHexString();
toOctalString();
其他进制 ---> 十进制
parseInt(string,index);
基本数据类型包装类新特性:JDK1.5之后 自动装箱拆箱 简化书写
Integer i = 4;//i = new Integer(4);
i= i+6;//i = new Integer(i.intValue() + 6);
Integer i = null;//当值为null时调用intValue方法会出现异常
Integer a = new Integer(127);
Integer b = new Integer(127);
System.out.println(a==b);//false
System.out.println(a.equals(b));//true
Integer x = 127;
Integer y = 127;
System.out.println(x==y);//true JDK1.5以后,自动装箱,如果装的是一个字节,那么还数据会被共享不会重新开辟空间
System.out.println(x.equals(y));//true
Integer a = new Integer(128);
Integer b = new Integer(128);
System.out.println(a==b);//false
System.out.println(a.equals(b));//true
Integer x = 128;
Integer y = 128;
System.out.println(x==y);//false
System.out.println(x.equals(y));//true
Integer类(重点)
1.字段:如 static int MAX_VALUE
它表示 int 类型能够表示的最大值。
static int MIN_VALUE
它表示 int 类型能够表示的最小值。
2.构造方法:
A.Integer(int value)
构造一个新分配的 Integer 对象,将int类型的value变成Integer类型的。
eg. int num=100;
Integer i =new Integer(num);
System.out.println(i); //100
===>JDK5.0之后的新特性:
a.自动装箱,也就是把基本类型直接复制给引用类型。
eg.Integer i = 100;
b.自动拆箱,也就是把引用类型直接拆成基本类型。
eg. Integer i = 100;
i = i+200;//先拆箱后装箱
==>但是要注意对i进行不为null判断,当i为null时,会报指针异常。
B.Integer(String s)
构造一个新分配的 Integer 对象,将String类型的s变成Integer类型的,这里的s只能是数字形式的字符串,不能含有非数字字符。
eg. String s = "1";
Integer ii = new Integer(s);
System.out.println(s);//1
3.成员方法:
A.进制转换
static String toBinaryString(int i)
以二进制(基数 2)无符号整数形式返回一个整数参数的字符串表示形式。
static String toHexString(int i)
以十六进制(基数 16)无符号整数形式返回一个整数参数的字符串表示形式。
static String toOctalString(int i)
以八进制(基数 8)无符号整数形式返回一个整数参数的字符串表示形式。
eg.
System.out.println(Integer.toBinaryString(60));//111100
B.int类型数据与String类型的数据之间的相互转换:
推荐方法:
int--->String
1)String.valueOf(int i)
2)Integer.toString(int i)
String --int
Integer.parseInt(String s)
public class StringAndInt {
public static void main(String[] args) {
int num = 100;
//int--->String
//方式一:开发常见,但是不专业
String s1 = num+"";
//方式二(推荐):String的静态方法:public static String valueOf(int i)
String s2 = String.valueOf(num);
//方式三:int--Integer--String
Integer i = new Integer(num);
String s3 =i.toString();
//方式四(推荐):Integer的静态方法:public static String toString(int i)
String s4 = Integer.toString(num);
//String--->int
String s = "100";//注意这里的s只能是数字形式的字符串!
//方式一:String--Integer--int
//调用Integer的 public int intValue()
Integer ii= new Integer(s);
int num2 = ii.intValue();
//方式二(推荐):调用Integer的静态方法 public static int parseInt(String s)
int num3 = Integer.parseInt(s);
}
}
4.byte常量池(面试题)
四、Object类
1.Object类是所有类默认的的父类,被称为根类。2.重要方法:
A.tostring():用于输出对象地址值。
eg.
public class StudentTest
{
public static void main(String[] args)
{
Student s = new Student();
System.out.println(s);//此句与下面那句是等效的
System.out.println(s.toString());
}
}
打印结果:Object.Student@1833eca
Object.Student@1833eca
注:1.用输出语句直接输出对象的名称,其实底层调用了该对象的toString()方法;
2.为了让对象的显示有意义,一般Object的子类都重写了该方法。
B.equals():用于比较对象是否相等,比较的是地址值;而一般来说,同一个类的不同对象,地址值肯定不一样,
Object类的equals()方法的默认操作是没有意义的。所以,我们一般会根据需求重写此方法,如用于比较
类的成员变量值是否相等。
a.重写equals()一般就是为了比较某个类的多个对象的所有成员变量值是否相等
如果成员变量是基本类型,就用==比较;
如果成员变量是引用类型,就用该变量所对应的数据类型的equals()方法比较。
eg.Student类中比较成员变量的函数:
public boolean equals(Object obj)//参数Object类型的,也就是说任何类型的对象都可以传入(向上默认自动转型)
{
if(this==obj)//为了提高代码效率,对传入的对象做一个是否是自己的判断。
{
return true;
}
if(!(obj instanceof Student))//为提高代码健壮性,对传入对象做一个是否为Student类型的判断;
{
return false;
}
Student s = (Student) obj;//向下转型
return this.age==s.age && this.name.equals(s.name);
}//这里this.name是String类型,则其调用的就是String类的equals()方法。
五、与时间有关的类
DateFormat的子类。
1.构造方法:
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat的对象。
常用的两种用法:
1)从Date类型向String类型转;
public final String format(Date date)//这个方法存在于其父类DateFormat中,其内并没有重写,所以找的时候在DateFormat中找。
常见日期模式:
yyyy年MM月dd日 HH:mm:ss
yyyy年MM月dd日
HH:mm:ss
yyyy-MM-dd HH:mm:ss
……
eg.
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatTest {
public static void main(String[] args) {
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String str = sdf.format(d);
System.out.println(str);
}
}
结果:2014年09月25日 22:38:23
2)从String类型向Date转。
Date parse(String source)//这个方法存在于其父类DateFormat中,其内并没有重写,所以找的时候在DateFormat中找。
从给定字符串的开始解析文本,以生成一个日期。
注意点:如果是字符串到日期的转换,自己指定的日期模式必须与字符串的格式相同。
eg.
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatTest2 {
public static void main(String[] args) throws ParseException {
String s ="2014-09-24 11:30:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//必须与s的格式一样!
Date d = sdf.parse(s);
System.out.println(d);
}
}
===>如果给了你一个格式的String,让你输出另一个格式的Date。
思路:String==>转成同形式的Date==>转换成另一种形式的String并输出。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatTest2 {
public static void main(String[] args) throws ParseException {
String s ="2014-09-24 11:30:00"; //给的是这个形式的String
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date d = sdf.parse(s); //换成上述形式的Date
SimpleDateFormat sdf2 = new SimpleDateFormat("dd-MM-yyyy");
String s2 = sdf2.format(d); //再把上边的Date换成所要的形式的String
System.out.println(s2);
}
}
输出:24-09-2014