java常用类

1、Object类(掌握)

         (1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。

         (2)Object类的构造方法有一个，并且是无参构造

                   这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造

         (3)要掌握的方法：

                   A:toString()

返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。这个表示其实是没有意义的，一般子类都会重写该方法。如何重写呢?过程我也讲解过了，基本上就是要求信息简单明了。但是最终还是自动生成。

                   B:equals()

比较两个对象是否相同。默认情况下，比较的是地址值是否相同。而比较地址值是没有意义的，所以，一般子类也会重写该方法。重写过程，我也详细的讲解和分析了。但是最终还是自动生成。

         (4)要了解的方法：

                   A:hashCode()返回对象的哈希值。不是实际地址值，可以理解为地址值。

                   B:getClass()返回对象的字节码文件对象，反射中我们会详细讲解      

                   C:finalize()用于垃圾回收，在不确定的时间

                   D:clone()可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指    向同一个对象是有区别的。

         (5)两个注意问题

                   A:直接输出一个对象名称，其实默认调用了该对象的toString()方法。

                   B:==和equals()的区别?

                            A:==

                                     基本类型：比较的是值是否相同

                                     引用类型：比较的是地址值是否相同

                            B:equals()

只能比较引用类型。默认情况下，比较的是地址值是否相同。但是，我们可以根据自己的需要重写该方法。

2、Scanner的使用(了解)

         (1)在JDK5以后出现的用于键盘录入数据的类。

         (2)构造方法：

                   A:讲解了System.in这个东西。

                            它其实是标准的输入流,对应于键盘录入

                   B:构造方法

                            InputStreamis = System.in;

                            Scanner(InputStreamis)

                   C:常用的格式

                            Scannersc = new Scanner(System.in);

         (3)基本方法格式：

                   A:hasNextXxx()判断是否是某种类型的

                   B:nextXxx()       返回某种类型的元素

         (4)要掌握的两个方法

                   A:publicint nextInt()

                   B:publicString nextLine()

         (5)需要注意的小问题

                   A:同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。

                   B:解决方案：

                            a:重新定义一个Scanner对象

                            b:把所有的数据都用字符串获取，然后再进行相应的转换

3、String类的概述和使用(掌握)

         (1)多个字符组成的一串数据。其实它可以和字符数组进行相互转换。

         (2)构造方法：

                   A:publicString()：空构造

                   B:publicString(byte[] bytes)：把字节数组转成字符串

                   C:publicString(byte[] bytes,int offset,int length)：把字节数组的一部分转成字符串

                   D:publicString(char[] value)：把字符数组转成字符串

                   E:publicString(char[] value,int offset,int count)：把字符数组的一部分转成字符串

                   F:publicString(String original)：把字符串常量值转成字符串

                   G:publicint length()：返回此字符串的长度。

                   H:Strings = "hello"; 这个虽然不是构造方法，但是结果也是一个字符串对象

         (3)字符串的特点

                   A:字符串一旦被赋值，就不能改变。

                            注意：这里指的是字符串的内容不能改变，而不是引用不能改变。

                   B:字面值作为字符串对象和通过构造方法创建对象的不同

                            Strings = new String("hello");和String s ="hello"的区别?

                            前者会创建两个对象，后者创建一个对象

         (4)字符串的面试题(看程序写结果)

                   A:==和equals()

                            Strings1 = new String("hello");

                            Strings2 = new String("hello");

                            System.out.println(s1== s2);// false

                            System.out.println(s1.equals(s2));//true

 

                            Strings3 = new String("hello");

                            Strings4 = "hello";

                            System.out.println(s3== s4);// false

                            System.out.println(s3.equals(s4));//true

 

                            Strings5 = "hello";

                            Strings6 = "hello";

                            System.out.println(s5== s6);// true

                            System.out.println(s5.equals(s6));//true

                   B:字符串的拼接

                            Strings1 = "hello";

                            Strings2 = "world";

                            Strings3 = "helloworld";

                            System.out.println(s3== s1 + s2);// false

                            System.out.println(s3.equals((s1+ s2)));// true

 

                            System.out.println(s3== "hello" + "world");// false 这个我们错了，应该是true

                            System.out.println(s3.equals("hello"+ "world"));// true

         (5)字符串的功能

                   A:判断功能

boolean equals(Object obj)：比较字符串的内容是否相同,区分大小写

boolean equalsIgnoreCase(String str)：比较字符串的内容是否相同,忽略大小写

boolean contains(String str)：判断大字符串中是否包含小字符串

boolean startsWith(String str)：判断字符串是否以某个指定的字符串开头

boolean endsWith(String str)：判断字符串是否以某个指定的字符串结尾

boolean isEmpty()：判断字符串内容是否为空。

注意：字符串内容为空和字符串对象为空。

                                    String s ="";和String s = null;(无对象不能调方法)               

B:获取功能（修饰符：public）

int length()：获取字符串的长度。

char charAt(int index)：获取指定索引位置的字符

int indexOf(int ch)：返回指定字符在此字符串中第一次出现处的索引。

        为什么这里是int类型，而不是char类型?

        原因是：'a'和97其实都可以代表'a'

int indexOf(String str)：返回指定字符串在此字符串中第一次出现处的索引。

         int indexOf(int ch,intfromIndex)：返回指定字符在此字符串中从指定位置后第一次出现处的索引。

         int indexOf(Stringstr,int fromIndex)：返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

         String substring(intstart)：从指定位置开始截取字符串,默认到末尾。包含指定位置。

         String substring(intstart,int end)：从指定位置开始到指定位置结束截取字符串。包含开始位置，不包含结束位置。

                   C:转换功能

byte[] getBytes()：把字符串转换为字节数组。（ASCII数值）

char[] toCharArray()：把字符串转换为字符数组。

static String valueOf(char[] chs)：把字符数组转成字符串。

static String valueOf(int i)：把int类型的数据转成字符串。

        注意：String类的valueOf方法可以把任意类型的数据转成字符串。

String toLowerCase()：把字符串转成小写。（本来值不变）

String toUpperCase()：把字符串转成大写。（本来值不变）

String concat(String str)：把字符串拼接。 

                   D:其他功能

                            a:替换功能

                                     Stringreplace(char old,char new)

                                     Stringreplace(String old,String new)

                            b:去字符串两端空格功能

                                     Stringtrim()

                            c:按字典比较功能

                                     intcompareTo(String str)  //比较两个字符串是否相等

                                     intcompareToIgnoreCase(String str)  //同上(忽略大小写)

4、StringBuffer类(掌握)

         (1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了一个字符串缓冲区类。StringBuffer供我们使用。

         (2)StringBuffer的构造方法

                   A:StringBuffer()：无参构造方法

                   B:StringBuffer(intsize)：指定容量的字符串缓冲区对象

                   C:StringBuffer(Stringstr)：指定字符串内容的字符串缓冲区对象

         (3)StringBuffer的常见功能

                   A:添加功能

         public StringBufferappend(String str)：可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

         public StringBufferinsert(int offset,String str)：在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

                   B:删除功能

                            publicStringBuffer deleteCharAt(int index)：删除指定位置的字符，并返回本身

public StringBuffer delete(int start,int end)：删除从指定位置（包括）开始指定位置（不包括）结束的内容，并返回本身

                   C:替换功能

                            publicStringBuffer replace(int start,int end,String str)：从start(包括)开始到                      end(不包括)用str替换

                   D:反转功能

                            publicStringBuffer reverse()

                   E:截取功能(注意返回值类型不再是StringBuffer本身)

                            publicString substring(int start)

                           public Stringsubstring(int start,int end)

         (4)StringBuilder

A:String，StringBuffer，StringBuilder的区别?

A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。

B:StringBuffer是同步的，数据安全，效率低;

  StringBuilder是不同步的，数据不安全，效率高

B:StringBuffer和数组的区别?

二者都可以看出是一个容器，装其他的数据。但是呢，StringBuffer的数据最终是一个字符串数据。而数组可以放置多种数据，但必须是同一种数据类型的。

C:形式参数问题

String作为参数传递

StringBuffer作为参数传递

形式参数：

                   基本类型：形式参数的改变不影响实际参数

                   引用类型：形式参数的改变直接影响实际参数

注意：String作为参数传递，效果和基本类型作为参数传递是一样的。      

5、数组高级以及Arrays(掌握)

         (1)排序

                   A:冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

                            publicstatic void bubbleSort(int[] arr) {

                                     for(intx=0; x<arr.length-1; x++) {

                                               for(inty=0; y<arr.length-1-x; y++) {

                                                        if(arr[y]> arr[y+1]) {

                                                                 inttemp = arr[y];

                                                                 arr[y]= arr[y+1];

                                                                 arr[y+1]= temp;

                                                        }

                                               }

                                     }

                            }

                   B:选择排序

把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小（最大）值出现在了0索引。同理，其他的元素就可以排好。

                            publicstatic void selectSort(int[] arr) {

                                     for(intx=0; x<arr.length-1; x++) {

                                               for(inty=x+1; y<arr.length; y++) {

                                                        if(arr[y]< arr[x]) {

                                                                 inttemp = arr[x];

                                                                 arr[x]= arr[y];

                                                                 arr[y]= temp;

                                                        }

                                               }

                                     }

                            }

         (2)查找

                   A:基本查找

                            针对数组无序的情况

                            publicstatic int getIndex(int[] arr,int value) {

                                     intindex = -1;

                                     for(intx=0; x<arr.length; x++) {

                                               if(arr[x]== value) {

                                                        index= x;

                                                        break;

                                               }

                                     }

                                     returnindex;

                            }

                   B:二分查找(折半查找)

                            针对数组有序的情况(一定要先排序，在查找)

                            publicstatic int binarySearch(int[] arr,int value) {

                                     intmin = 0;

                                     intmax = arr.length-1;

                                     intmid = (min+max)/2;

                                     while(arr[mid]!= value) {

                                               if(arr[mid]> value) {

                                                        max= mid - 1;

                                               }elseif(arr[mid] < value) {

                                                        min= mid + 1;

                                               }

                                               if(min> max) {

                                                        return-1;

                                               }

                                               mid= (min+max)/2;

                                     }

                                     returnmid;

                            }

                   如果找不到，返回查找值的相反数-1

         (3)Arrays工具类

                   A:是针对数组进行操作的工具类。包括排序和查找等功能。

                   B:要掌握的方法（所有类型的数据类型）

                            把数组转成字符串：publicstatic String toString(int[] a)

                            排序：publicstatic void sort(int[] a)

                            二分查找：publicstatic int binarySearch(int[] a,int key)

                   开发原则：只要是对象，我们就要判断该对象是否为null。

         (4)Arrays工具类的源码解析

6、Integer类(掌握)

         (1)为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型

                   byte                 Byte

                   short                  Short

                   int                       Integer

                   long                    Long

                   float                   Float

                   double               Double

                   char                    Character

                   boolean             Boolean

         (2)Integer的构造方法

                   A:Integeri = new Integer(100);

                   B:Integeri = new Integer("100");

                            注意：这里的字符串必须是由数字字符组成

         (3)String和int的相互转换

                   A:String-- int

                            Integer.parseInt("100");

                   B:int-- String

                            String.valueOf(100);

         (4)其他的功能(了解)

A:常用的基本进制转换

public static String toBinaryString(int i)： 十进制转换二进制

public static String toOctalString(int i)：十进制转换八进制

public static String toHexString(int i)：十进制转换十六进制

B:十进制到其他进制

public static String toString(int i,int radix)

由这个我们也看到了进制的范围：2-36

为什么呢?0,...9,a...z

C:其他进制到十进制

public static int parseInt(String s,intradix)

(5)JDK5的新特性

                   自动装箱(AutoBoxing)             基本类型—>引用类型

                   自动拆箱(AutoUnBoxing)        引用类型—>基本类型

7、Character类(了解)

         (1)Character构造方法  

                   Characterch = new Character('a');

         (2)要掌握的方法

                   A:判断给定的字符是否是大写：publicstatic boolean isUpperCase(char ch)

                   B:判断给定的字符是否是小写：publicstatic boolean isLowerCase(char ch)

                   C:判断给定的字符是否是数字字符：public static boolean isDigit(char ch)

                   D:把给定的字符转成大写：publicstatic char toUpperCase(char ch)

                   E:把给定的字符转成小写：publicstatic char toLowerCase(char ch)

8、正则表达式(理解)

         (1)就是符合一定规则的字符串

         (2)常见规则

                   A:字符

                            x     字符 x。举例：'a'表示字符a

                            \\    反斜线字符。

                            \n   新行（换行）符 ('\u000A')

                            \r    回车符 ('\u000D')

                   B:字符类

                            [abc]                a、b 或 c（简单类）

                            [^abc]              任何字符，除了 a、b 或 c（否定）

                            [a-zA-Z]  a到 z 或 A到 Z，两头的字母包括在内（范围）

                            [0-9]                 0到9的字符都包括

                   C:预定义字符类

                            .      任何字符。.字符本身用表示\.。

                            \d   数字：[0-9]

                            \w  单词字符：[a-zA-Z_0-9]

                                     在正则表达式里面组成单词的东西必须有这些东西组成

                   D:边界匹配器

                            ^     行的开头

                            $     行的结尾

                            \b   单词边界：就是不是单词字符的地方。

                                     举例：helloworld?haha;xixi

                   E:Greedy数量词

                            X?              X，一次或一次也没有

                            X*              X，零次或多次

                            X+              X，一次或多次

                            X{n}           X，恰好 n 次

                            X{n,}          X，至少 n 次

                            X{n,m}      X，至少 n 次，但是不超过 m 次

         (3)常见功能：(分别用的是谁呢?)

                   A:判断功能

                            String类的publicboolean matches(String regex)

                   B:分割功能

                            String类的publicString[] split(String regex)

                   C:替换功能

                            String类的publicString replaceAll(String regex,String replacement)

                   D:获取功能

                            Pattern和Matcher

                                     Patternp = Pattern.compile("a*b");

                                     Matcherm = p.matcher("aaaaab");

                                     find():查找存不存在满足条件的子串

                                     group():获取刚才查找过的数据

9、Math类(掌握)

         (1)针对数学运算进行操作的类

                   成员变量：

public static final double PI               （PI = 3.14）

                            publicstatic final double E                 （E = 2.71）

         (2)常见方法

                   A:绝对值：publicstatic int abs(int a)

                   B:向上取整：publicstatic double ceil(double a)

                   C:向下取整：publicstatic double floor(double a)

                   D:两个数据中的大值：publicstatic int max(int a,int b)

                   E:a的b次幂：publicstatic double pow(double a,double b)

                   F:随机数：publicstatic double random()

                   G:四舍五入：publicstatic int round(float a)

                   H:正平方根：publicstatic double sqrt(double a)

10、Random类(理解)

         (1)用于产生随机数的类

         (2)构造方法:

                   A:Random()默认种子，每次产生的随机数不同

                   B:Random(longseed) 指定种子，每次种子相同，随机数就相同

         (3)成员方法:

                   A:intnextInt() 返回int范围内的随机数

                   B:intnextInt(int n) 返回[0,n)范围内的随机数

11、System类(掌握)

         (1)系统类,提供了一些有用的字段和方法

         (2)成员方法

                   A:publicstatic void gc()：运行垃圾回收器。

B:public static void exit(int status)：终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。

                   C:publicstatic long currentTimeMillis()：返回以毫秒为单位的当前时间

                   D:publicstatic void arraycopy(Object src,int srcPos,Object dest,int destPos,int          length)：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位     置结束。

12、BigInteger类(理解)

         (1)针对大整数的运算

         (2)构造方法

                   A:publicBigInteger(String s)

         (3)成员方法

A:public BigInteger add(BigInteger val)：加

B:public BigInteger subtract(BigInteger val) :减

C:public BigInteger multiply(BigInteger val) :乘

D:public BigInteger divide(BigInteger val) :除

E:public BigInteger[] divideAndRemainder(BigInteger val) :返回商和余数的数组

13、BigDecimal类(理解)

         (1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)

         (2)构造方法

                   A:publicBigDecimal(String s)

         (3)成员方法：

A:public BigDecimal add(BigDecimal augend)：加

B:public BigDecimal subtract(BigDecimal subtrahend)：减

C:public BigDecimal multiply(BigDecimal multiplicand)：乘

D:public BigDecimal divide(BigDecimal divisor)：除

E:public BigDecimal divide(BigDecimal divisor,int scale,introundingMode)：商，几位小数，如何舍取

14、Date/DateFormat类(掌握)

         (1)Date是日期类，可以精确到毫秒。

                   A:构造方法

                            Date()

                            Date(longtime)

                   B:成员方法

                            getTime()

                            setTime(longtime)

                   C:日期和毫秒值的相互转换

(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat

                   A:SimpleDateFormat(Stringpattern) 给定模式

                            yyyy-MM-ddHH:mm:ss

                   B:日期和字符串的转换

                            a:Date-- String(格式化)

                                     publicfinal String format(Date date)

                            b:String-- Date(解析)

                                     publicDate parse(String source)

15、Calendar类(掌握)

         (1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。

         (2)如何得到一个日历对象呢?

                   CalendarrightNow = Calendar.getInstance();

                   本质返回的是子类对象

         (3)成员方法

                   A:publicint get(int field)：返回给定日历字段的值。日历类中的每个日历字段都是      静态的成员变量，并且是int类型。

         例：int year = rightNow.get(Calendar.YEAR);         //获取年

         B:public void add(intfield,int amount)：根据给定的日历字段和对应的时间，来对当前的日历进行操作。

         例：rightNow.add(Calendar.YEAR,-3);  //三年前

C:public final void set(int year,int month,int date)：设置当前日历的年月日

         例：rightNow.set(2015,11, 11);    //2015年12月11日