Object
v 万类之祖Object类,java中的所有类都直接或间接的继承自Object。
v 构造方法:
§ Object()
v 常用方法:
§ String toString();
§ int hashCode();
§ boolean equals(Object obj);
字符串
v 字符串是字符的序列,它是组织字符的基本数据结构,从某种程度上来说有些类似于字符的数组。
v 在Java中,字符串被当作对象来处理。程序中需要用到的字符串可以分为两大类:
§ 一类是创建之后不会再做修改和变动的字符串常量--String;
§ 另一类是创建之后允许再做更改和变化的字符串变—StringBuffer / StringBuilder;
字符串对应类
v String:对于字符串常量,由于程序中经常需要对它做比较,搜索之类的操作,所以通常把它放在一个具有一定名称的对象之中,由程序对该对象完成上述操作。在Java中,存放字符串常量的对象用String类。
v StringBuffer/ StringBuilder :对于字符串变量,由于程序中经常需要对它做添加,插入,修改等操作,一般存放在StringBuffer/ StringBuilder类的对象中。 StringBuffer是线程安全;StringBuilder没有实现线程同步,但速度更快建议使用。
String类
v Java.lang.String类是一个特殊的类,可以不用new创建对象;如:String str1=“Hello world!”; Java编译器自动为字符串常量生成一个String类的实例,因此可以用字符串常量直接初始化一个String对象;程序对字符串处理最多,因此String提供了很多字符串操作方法。
v 注意:以下代码的两者的区别
§ String str = “”; //长度为0的字符串.
§ String str = null;
v 构造方法:
§ String()
v String s = new String( );
§ String(byte[] by) /String(byte[] by,int offset,int length)
v byte[] bytes={97,98,99};
v String s=new String(bytes);
§ String(char[] ch) /String(char[] ch,int offset,int length)
v char chars[ ] = { ‘a’ , ‘b’ , ‘c’ };
v String s = new String( chars );
§ String(String value)
v String s1 = new String(“hello”);
v String s2 = new String(s1);
v equals和==的区别
equals 值比较
== 地址比较
v 注:String重写了Object类中的hashCode(), equals(), toSting()方法;
String(+)
v +
在Java中,运算符“+”可以用来实现字符串的连接,如:String s = “He is” +age + “years old.”假设整数型变量age的值为15,那么,s的值为 “He is 15 yearsOld”。
v public String concat(String str);
将当前字符串对象与给定的字符串str连接起来。
String(split)
v StringTokenizer 是出于兼容性的原因而被保留的遗留类(不建议使用)。建议使用 String 的 split 方法或 java.util.regex包中的方法来替代
String[] result = "this is atest".split("\\s");
for (int x=0; x<result.length; x++){
System.out.println(result[x]);
}
StringBuffer常用构造方法
v java.lang.StringBuffer也可描述字符串,代表可变的字符序列(注:StringBuffer是线程安全的);
v 常用构造方法:
§ StringBuffer() //构造一个其中不带字符的字符串缓冲区,其初始容量为 16 个字符
§ StringBuffer(String str) //构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容
§ StringBuffer(int capacity) //构造一个不带字符,但具有指定初始容量的字符串缓冲区
StringBuilder类
v 一个可变的字符序列,此类提供一个与 StringBuffer 兼容的 API,但不保证同步。该类被设计用作 StringBuffer 的一个简易替换,建议优先采用该类,因为在大多数实现中,它比StringBuffer 要快;
v 常用的构造方法:
§ // 1. StringBuilder()
§ // 3. StringBuilder(String str)
§ // 2. StringBuilder(intcapacity)
基本数据类型转换
v 在Java中,一切都是对象,但基本的数据类型不是对象。因此在JDK中提供了基本数据类型的封装类对象。
v 八个基本数据类型对应的封装类(wrapper class):
§ boolean --> Boolean
§ char --> Character
§ byte --> Byte
§ short ---> Short
§ int --> Integer
§ long --> Long
§ float --> Float
§ double --> Double
v 八个基本数据类型都重写了Object中的hashCode(), equals(), toString()方法。
类型转换
v 基本类型--->封装类型
§ Integer inObj = new Integer(10);
§ System.out.println(inObj);
v 封装类型--->基本类型
§ int i = inObj.intValue();
§ System.out.println(i);
v 基本类型---->字符串
§ String stri = String.valueOf(i);
§ System.out.println(stri);
v 字符串---->基本类型
§ int inti = Integer.parseInt("100");
§ System.out.println(inti);
要点补充:
1:API的使用
java.io(输出输出流的包)
java.lang(系统常用类的包__不需要导包)
java.util(常用工具类的包)
java.math(大数字对象的操作包)
java.sql(Java跟数据库交互的包)
java.net(Java网络包)
2:MyEcipse的断点调试功能的使用
Debug
F5:单步进入(进入某个方法中)
F6:单步退出(程序一步步的执行下去)
F7:回到原先的断点位置。
F8:跳到下一个断点。如果没有下一个断点,程序运行结束。
设定断点:双击
移除断点:在断点上再双击
跳过所有的断点:在断点界面,选择Run--->Skip AllBreakPoints
移除所有的断点:在断点界面,选择Run--->Remove AllBreakPoints
3:系统常用类
==========
String
日期的格式化
数字(小数点)的格式化
==========
集合框架
异常处理
IO流
界面编程
网络编程
多线程编程
4.Object对象。
Object对象是所有对象的根类。每个对象都默认继承自Object类。
equals():对象与对象之间是否相等。
逻辑上面的相等。equals
物理上面的相等(地址相等) ==
两个对象逻辑相等的话,必须要重写对象的equals方法。
toString():返回对象的字符串表示
com.test_object.Person@de6ced
com.test_object.Person:表示对象的包路径与类名
de6ced:对象的哈希码,由哈希算法生成,在一定程度可
以表示对象在内存中的位算。(不同对象的哈希码有可能重复。)
hashCode():返回对象的哈希码。
5:字符串对象
1.字符串的初始化
2.equals
3.split
4.indexOf、lastIndexOf,substring
5.连接:concat,+
6.charAt
7.endsWith
8.trim
9.replaceAll
10.=hell和 newString("hell")区别;
字符串是一连串字符的序列。是由字符数组构成的。
字符串:
A:字符串常量:String
B:字符串变量:StringBuffer/StringBuilder
字符串常量:
常量区。值不能改变。
字符串是Java中唯一一个不用new就可以直接使用的对象。
定义字符串
Stringstr3; //声明一个对象。对象的初始化值为null
Stringstr = null;
Stringstr2 = ""; //声明一个对象,并为其赋初始值为""
//字符串的初始化
直接初始化
使用构造方法初始化。
//字符串的比较
字符串比较用eqals(),不要用==。
//字符串常用方法:
charAt(intindex)
返回指定索引处的 char 值。
compareTo(StringanotherString) 按字典顺序比较两个字符串的大小
concat(Stringstr) 将指定字符串联到此字符串的结尾
字符串的连接一般使用+号。
+:是将字符串的值重新进行指向。不是在原有的基础上面改的。
常量是不能被修改的。
因此:+是将原先的值进行Copy,然后与现在的新值进行合并的过程。
endsWith(Stringsuffix) /startsWith
测试此字符串是否以指定的后缀/前缀结束。
toLowerCase();
toUpperCase();
字符串的查找与替换
indexOf
lastIndexOf
subString();
replace()
replaceAll
字符串的分割
split();
字符串的长度
length()
trim()
6.StringBuffer
StringBuffer()建立空的缓冲区,默认程度为16
StringBuffer(Stringstr)缓冲区的初始内容为str,并提供了16个字符串的空间供再次分配
length;append;toString();charAr();setCharAt();insert();
一个类似于 String 的字符串缓冲区,但不能修改。
但是通过调用append或者insert来改变StringBuffer的内容与长度。
7.StringBuilder:
一个与StringBuffer功能完全相同的类。但是StringBuilder是
非线程同步的。因此速度比StringBuffer来的话。
1.string不可变,Stringbuffer可变
2.string+
8=============================
Java语言用包装类来把基本类型数据转为对象
作用:
1.类型转换
2.集合无法用基本数据类型,要用包装类
构造:
1。可用对应的基本数据类型来构造,
2.除character,7种可以用字符串来构造, boolean参数为string,内容为true,则true,否则为false
string不得为null,类型必须可解析为相应的基本类型的数据,否则异常。
包装类方法:
1。覆盖了toString方法,以字符串形式返回包装对象所表示的基本类型数据
2.除Character和Boolean类外,包装类都有valueOf静态方法,可以根据string类型的参数来创建包装类对象,不为null
3.除Character和Boolean类外,包装类都有parseXXX静态方法,把字符串转为基本类型的数据
===================================================
1:基础数据与封装类型之间的转型
A:基础数据类型--->封装类型(对象类型)
Booleanboolean_1 = new Boolean(true);
byte---->Byte
short---->Short
char---->Character
int--->Integer
long-->Long
float-->Float
double-->Double
B:封装类型--->基础类型
Integer.intValue--->int
Folat.floatValue--->float
Double.doubleValue--->Double
2:包装类与字符串之间的转换
调用String.valueOf()方法。
Stringstr = String.valueOf(任何数据类型);
3:字符串转成基本数据类型
调用封装类的parse方法。
int i = Integer.parseInt("100");
double d =Double.parseDouble("12.334");
4:Characeter的一些常用方法:
Character主要配合String对象,对String对象做一些简单的验证。
String.chatAt(i);//例
Pattern pattern =Pattern.compile("\\d{11}");
Matcher matcher =pattern.matcher(phone);
if(matcher.find() == true) {
简单的数据验证
正则表达式(EE初级)
java.util.regex包下面
Pattern:编译正则表达式
Matcher:查找字符串是否与正则表达式匹配。
5:String对象有length这个方法。数组有length这个属性。
============================
private static void equals() {
Stringstr = "abc";
Stringstr2 = "abc";
Stringstr3 = new String("abc");
char[]charArray = { 'a', 'b', 'c' };
Stringstr4 = new String(charArray);
System.out.println(str== str2);// true
System.out.println(str.equals(str2));//true
System.out.println(str3== str4);// false
System.out.println(str3.equals(str4));//true
}
=================================
字符串的构造方法
直接用文字构造
使用String的构造方法构建。
两者的差别
String s="abce"是一种非常特殊的形式,和new有本质的区别.
它是java中唯一不需要new 就可以产生对象的途径.
以 String s="abce";形式赋值在java中叫直接量,它是在常量池中而不是象new一样放在压缩堆中.
这种形式的字符串,在JVM内部发生字符串驻留,即当声明这样的一个字符串后,
JVM会在常量池中先查找有有没有一个值为"abcd"的对象,如果有,就会把它赋给当前引用.
即原来那个引用和现在这个引用指点向了同一对象,如果没有,则在常量池中新创建一个"abcd",
下一次如果有String s1 = "abcd";又会将s1指向"abcd"这个对象,即以这形式声明的字符串,
只要值相等,任何多个引用都指向同一对象.
而String s = new String("abcd");和其它任何对象一样.每调用一次就产生一个对象.
只到它们调用intern()方法时才会产生上面那种效果.
转载于:https://my.oschina.net/u/2552902/blog/543815