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

关于学习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）、基本数据类型对应的引用类型。

 *       基本类型                引用类型*       int                 Integer*        char                Character*      byte                Byte*       boolean             Boolean*        double              Double*         float               Float*      long                Long*       short               Short

* 将基本类型--->引用类型的作用:就是为了和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));}