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()方法时才会产生上面那种效果.