关于学习Java中常用类的总结

一、序言

   由于第一次写博客，而且也已经决定走Java方向，还是想先简单聊聊JAVA面向对象的编程思想，之前在学习的过程中，听到一个老师对其最后的总结为“以类的方式组织代码，以对象的方式组织（封装）数据”随着学习的深入，也慢慢开始理解这句话。

   对象：现实生活中具体的事务。

   类：是对对象的抽象。

   类作为编程中最基本的单位，它可以构成我们想要表达的所有事务，而最近刚好在张老师那里学到几个常用类，接下来是我的学习总结。

二、学习总结——常用类

1、object类

object作为所有类的超类，无论是四类八种的基本类型还是引用类型或者是自定义类型都需要extends Object,所以其自然有着强大的功能，它的主要方法有

需要注意的几个方法，

       （1）、finalize:protected void finalize() throws Throwable:当垃圾回收器确定不存在对该对象的更过引用时，由对象的垃圾回收器调用会此方法，但是什么时候调用垃圾回收器不确定。在System类中的一个方法：   public void gc()垃圾回收器最终调用的就是这个方法。

       （2）、clone: Object类中的clone方法执行特定的复制操作，首先如果对象不能实现接口Cloneable，则会抛出 CloneNotSupportedException。

       （3）、toString：在平时编程中，我们都有这样的发现  System.out.println(oo)的输出与Systeml.out.println(oo.toString)输出结果一样， 为什么呢？

          这是因为System.out.println方法在打印引用时若引用不为空，则首先调用指向对象的toString方法获取字符串，然后打印字符串的内容，当然如果我们没有重写toString方法，就按Object类实现获取字符串，打印出来的内容就是this.getClass.getName + @ + Integer.toHexString(this.hashCode)，一般就比较难理解，所以好多大神都建议当自定义类时，最好重写toString方法,这样我们也就可以显示成员变量的值。

       （4）、equals：方法的重要意义

          在一般初学者眼里，觉得自己能够辨识”equals“方法和”==“就很流弊了，前者比较其实例的值，后者比较实例的地址。很对，但是如果你不深入理解源码去看的话，很容易掉入各大公司的陷阱里面。其实equals的底层实现依然是”==“，以下为源码：

惊不惊喜？意不意外？

所以，如果你业务有需要，想实现equals方法最终输出为true,那还是乖乖的在自定义时重写equals方法吧，又会问，那int、char、String等方法也没见我重写啊，输出来就是true啊，那是因为可爱的Java创始人在JDK5.0就创造了包装类。所谓包装类我把他定义为数据类型界的暖男，平时不声不响，当他的女朋友——基本数据类型或String类需要处理数据时，他就会默默的为”她“auto-boxing,unbosing(自动装箱、自动装箱)，当然此处你要把他两看作一家人（包装类有时候被我们简化，我们不能直观看到）。

2、Scanner类

           （1）、类的功能： 该类的主要作用就是建立一个文本扫描器（键盘录入），存在于java.util包下。在键盘的录入过程中，Scanner sc = new Scammer(System.in),

 System类中的静态字段为：

        public static final InputStream in:  标准输入流
     InputStream :字节流    InputStream is = System.in ;  实质:抽象类多态
     public static final OutputStream out:  标准输出流 

      （2）、判断功能：在录入数据之前添加逻辑判断，hasNextXXX()，判断是否由下一个可以录入的XXX类型的数据。nextXXX()，通过录入来获取这个int类型的数据，如果输入数据与判断数据不一致，则会抛出java.util.InputMismatchException(输入和想得到的数据不一致)

          （3）、注意事项：先录入int类型的数据再录入String类型的数据，String没有接收到，直接输出结果了，这是由于“回车”导致的，一回车。直接输出结果。

              解决方案有二：其一，使用next()方法，其二，再创建一个键盘输入对象录入String类型。

3、包装类的——Why?When?where?

    一个姓牛的人曾经说过，学习最大的动力就是永远有问不完的问题。（如果你没听说过这句话，那就现在盯着屏在看一遍吧）

  上了大概20年的学，我们都清楚，学知识有三问—Why?When?where?

       1）why？

      其实Java并不是纯面向对象的语言。比如，java中的基本数据类型就不是面向对象的，但是我们在实际运用中经常要将基本数据类型转化为对象便于操作。

      2）when??

     什么时候使用包装类？自然是你需要操作数据的时候，例如进制之间的相互转化、数据之间的比较（compare）、求出该类型的最大最小值...

      3） where???

     第一个where:   包装类都位于Java.lang包下

     第二个where:   至于在那用，根据具体问题具体定夺。

3、String类

           （1）、类的功能代表字符串，Java程序中所有的字符串字面值（如“abc”）都作为此类的实例实现，字符串一旦被赋值，其值不能被改变。

                       String s = "hello",与String s  = new String("hello")两个有什么区别？分别创建了几个对象？

                      答：第一个创建了一个对象，第二个创建了两个对象（堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量（开辟了地址空间））

           （2）、String类常用的构造方法:
                                       *         String():表示一个空字符序列。
                                                  *         public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
                                                  *         public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
                                                  *         public String(char[] value):将字符数组构造成一个字符串
                                                  *         public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
                                                  *         public String(String original):通过字符串常量构造一个字符串对象

            （3）、注意事项：其一、数组中没有length()方法，它有length属性。字符串中有length(),集合中没有length(),有size()获取集合中元素的数量。

                                              其二、字符串变量相加，先开辟空间，再相加。字符串常量相加，首先在字符串常量池中找，判断有没有这个常量值，没有需要创建，有，则直接返回。

            （4）、编码与解码格式一样（默认为GBK格式，一个中文对应两个字节。utf-8编码，一个汉字对应三个字节）。

            （5）、String类中的判断功能：

                                                 boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
                                                 boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
                                                 boolean contains(String str):判断str这个字符串是否包含在当前字符串中
                                                 boolean startsWith(String str):是否以str子字符串开头
                                                 boolean endsWith(String str):判断是否以str子字符串结尾
                                                 boolean isEmpty():判断字符串是否为空
            （6）、String类中转换功能：

                                                 String类的转换功能(重点)
                                                 byte[] getBytes():将字符串转换字节数组
                                                 char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
                                                 static String valueOf(char[] chs):将字符数组转换成字符串
                                                 static String valueOf(int i):将一个int类型的数据转换成字符串
                                           注意:
                                                 String类中的valueOf()可以将任何数据类型转换成字符串
                                                 String toLowerCase():将字符串全部转成小写
                                                 String toUpperCase():将字符串全部转换成大写
                                                 String concat(String str):字符串拼接方法

          （7）、String类的其他功能：

                                                替换功能:
                                                  *         public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
                                                  *         public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
                                                  *     去除字符串两端空格:
                                                  *         public String trim()
                                                两个字符串进行比较:
                                                  *         public int compareTo(String anotherString)  是Comparable接口中的方法(该接口可以实现一个自然排序)
                                                  *         Comparator接口可以比较器排序
         （8）、插播递归：

                                自己调用自己的方法，称为方法递归，递归的三个条件：A需要定义方法，B要有出口条件，C满足一定的规律

                               构造方法不能使用递归

4、StringBuffer类

          （1）、StringBuffer:线程安全的可变字符序列。

          （2）、StringBuffer的构造方法:
                                                 *     public StringBuffer    ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
                                                 *     public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
                                                 *     public StringBuffer(String str)
                                                 *         构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
          （3）、获取长度和容量的方法：

                                                 *     public int length():获取字符串长度数
                                                 *     public int capacity():获取当前字符串缓冲区的容量

          （4）、StringBuffer中的和添加有关的方法：
                                                 *    public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
                                                 *    public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

          （5）、StringBuffer的删除有关方法:
                                                 *         public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
                                                 *         public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!

           （6）、StringBuffer的反转功能:
                                                 *         public StringBuffer reverse():将此字符串中的字符序列直接反转
           （7）、StringBuffer的替换功能:
                                                 *     public StringBuffer replace(int start, int end,String str)
                                                         从指定位置开始到指定位置结束的字符用str子字符串去替代

           （8）、StringBuffer的截取功能:
                                                 *         public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
                                                 *         public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

            （9）、StringBuffer和String 的区别?
                                                *         StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代
                                                *         StringBuilder:线程不安全,单线程单纯为了提供执行效率!)
                                                *         String:普通的一个字符串,从内存角度考虑,耗费空间!
           （10）、StringBuffer和数组的区别？

                                                 都属于容器类型的变量，数组只能存储一种类型的数据，并且长度是固定的，StringBuffer可以存储任意类型的元素。

            （11）、静态代码块 ,构造代码块,构造方法的优先级问题:
                                                                                              静态代码块>构造代码块>构造方法...
                   例子：

class B{/*private static ArrayList<String> array ;public B(){array = new ArrayList<String>() ;}*///成员变量的位置public static B t1 = new B() ;public static B t2 = new B() ;{System.out.println("构造代码块");}static{System.out.println("静态代码块!");}}public class Demo {public static void main(String[] args) {B b = new B() ;//构 构 静 构//静态代码块 ,构造代码块,构造方法的优先级问题://静态代码块>构造代码块>构造方法...}}

5、Integer类

（1）、自动拆箱、自动装箱： 上面说到自动拆、装箱，这是在JDK5.0之后添加进来的（java的jkd5.0以后:还有一些新特性:可变参数,增强for循环,静态导入,枚举...）。引用前辈的话说，自动拆箱装箱其实就是编译器帮我们改进代码。

                                   例如：int  C = new Integer(15000);   相当于     new Integer(15000).intValue              //自动拆箱

                                    Integer B = 15000;   相当于  new Integer(15000).intValue              //自动装箱

                                   特别需要注意的是：   在【-128，127】之间的int数，JVM依然当作基本数据类型进行处理，目的是为了加快代码的执行效率。

（2）、基本数据类型对应的引用类型。

 * 基本类型引用类型 * intInteger * charCharacter * byteByte * booleanBoolean * doubleDouble * floatFloat * longLong * shortShort

                                      * 将基本类型--->引用类型的作用:就是为了和String类型作为转换

6、character

                      （1）、  Character 类：在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段

                         构造方法:
                              *         public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char 值。

                     （2）、* Character类的判断功能:
                              *     public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
                              *     public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
                              *     public static boolean isDigit(char ch)确定指定字符是否为数字。
                              *
                              * Character常用的转换功能:
                              *         public static char toUpperCase(char ch):将指定字符转换成大写
                              *         public static char toLowerCase(char ch):将指定字符转换成小写
                      （3）、  例题：  

                              第一题 * 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)

public class CharacterDemo2 {public static void main(String[] args) {//public static boolean isLowerCase(char ch)确定指定字符是否为小写字母System.out.println("isLowerCase:"+Character.isLowerCase('a'));System.out.println("isLowerCase:"+Character.isLowerCase('A'));System.out.println("isLowerCase:"+Character.isLowerCase('0'));System.out.println("---------------------------------------");//public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母System.out.println("isUpperCase:"+Character.isUpperCase('a'));System.out.println("isUpperCase:"+Character.isUpperCase('A'));System.out.println("isUpperCase:"+Character.isUpperCase('0'));System.out.println("---------------------------------------");//public static boolean isDigit(char ch)确定指定字符是否为数字。System.out.println("isDigit:"+Character.isDigit('a'));System.out.println("isDigit:"+Character.isDigit('A'));System.out.println("isDigit:"+Character.isDigit('0'));}}

                               第二题： 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)


                                          *     分析:
                                          *         1)定义三个统计变量
                                          *             bigCount
                                          *             smallCount
                                          *         numberCount
                                          * 2)创建键盘录入对象,录入并接收一个字符串
                                          * 3)将字符串转换成字符数组
                                          * 4)遍历字符数组,获取到每一个字符
                                          * 5)使用Character类中的判断功能判断是否是大写,小写,数字字符
                                          * 6)输出
                                          *         

public class CharacterTest {public static void main(String[] args) {//定义三个统计变量int bigCount = 0 ;int smallCount = 0 ;int numberCount = 0;//创建键盘录入对象Scanner sc = new Scanner(System.in) ;//录入并接收数据System.out.println("请您输入一个字符串:");String line = sc.nextLine();//将字符串转换成字符数组char[]  chs = line.toCharArray() ;for(int x = 0 ; x < chs.length ; x ++){//获取每一个字符char ch = chs[x] ;//判断if(Character.isUpperCase(ch)){bigCount ++ ;}else if(Character.isLowerCase(ch)){smallCount ++ ;}else if(Character.isDigit(ch)){numberCount ++ ;}}//输出System.out.println("大写字母字符共有:"+bigCount+"个");System.out.println("小写字母字符共有:"+smallCount+"个");System.out.println("数字字符共有:"+numberCount+"个");}}

7、冒泡排序

（1）、冒泡排序的思想：  两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....
 （2）、终极版冒泡排序代码：（在张老师的基础上，我又加了一个判断条件，避免数组已经排好序之后在重复排序）：

public static void Start(double[] arr) {for(int i=0;i<arr.length-1;i++) {boolean alread = true;//假定有序System.out.println("第"+ i+1 + "轮");for(int j=0;j<arr.length-1-i;j++) {if(arr[j]>arr[j+1]) {double temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;alread = false;//交换值了，说明之前是无序的}System.out.println(Arrays.toString(arr));//本轮排序后的数组}if(alread == true) {break;}}}public static void main(String[] args) {double[] d = {10,50,400.2,600,900};Start(d);System.out.println(Arrays.toString(d));}