菜鸡的Java笔记 java基础类库 BaseClassLibrary

java基础类库 BaseClassLibrary
        StringBuffer 类的特点
        StringBuffer,StringBuilder,String 类之间的关系
    
    
    StringBuffer 类
        String 类有哪些特点？
            字符串常量就是String 类的匿名对象，一旦字符串定义则不可改变
            String 类对象可以使用直接赋值或者构造方法实例化，前者可以自动入池，又不会产生垃圾空间
        在实际的开发之中，肯定都要求使用到String类，可是String有一个天生的短板：不可改变，所以如果要想面对经常修改的环境下只能够使用StringBuffer 类
        在String类中可以使用“+”来实现字符串的连接操作，而在 StringBuffer 类中可以使用 append() 方法实现“+”的功能
        如方法定义如下：
            public StringBuffer append(数据类 变量)
            
        范例：利用StringBuffer 修改字符串

package cn.mysterious.study3;

public class StringBufferClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StringBuffer buf = new StringBuffer();
        buf.append("Hello").append("World!!!"); // 连接字符串
        fun(buf); // 修改字符串的内容
        System.out.println(buf);
    }
    public static void fun(StringBuffer temp){ // 引用传递
        temp.append("
该学习了！");
    }
}

           
        此时的执行结果之中发现字符串的内容已经得到了改变，所以StringBuffer适合与修改，而String不适合修改
        原则：在开发之中95%的情况下使用的都应该是String（String只是不适合于频繁修改），所以不可能通过循环操作SQL，但是如果真的是进行连接操作，还建议使用“+”。如果真的是循环修改，还是使用StringBuffer 好
        现在字符串类有两个类：StringBuffer，String，那么这两个什么关系呢？
            查看文档观察继承结构：
            String 类：                    
                public final class Stringextends Objectimplements Serializable, Comparable<String>, CharSequence
            StringBuffer 类
                public final class StringBufferextends Objectimplements Serializable, CharSequence
                    
        发现String和StringBuffer类都是 CharSequence 接口的子类，所以在日后一定要记住，String或StringBuffer都是可以向上转型为 CharSequence 接口实例化

    package cn.mysterious.study3;

    public class StringBufferClass {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            String str = "nul" + "kong" + "空";
            CharSequence cs = str; // 向上转型
            System.out.println(cs.subSequence(5, 8));
        }
    }

           
        但是现在出现了一个问题，String 与StringBuffer 类的对象该如何互相转换呢？
            对于这两个类对象的互相转换就可以利用一下原则完成：  
            1.String 转换为StringBuffer 这种转换有两种操作途径：
                利用StringBuffer 类的构造方法： public StringBuffer(String str)

    package cn.mysterious.study3;

    public class StringBufferClass {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            String str = "nul" + "kong" + "空";
            StringBuffer s = new StringBuffer(str);
            System.out.println(s);
        }
    }
       

        
                StringBuffer 类存在有 append() 方法：public StringBuffer append(String str)

    package cn.mysterious.study3;

    public class StringBufferClass {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            String str = "nul" + "kong" + "空";
            StringBuffer s = new StringBuffer();
            s.append(str);
            System.out.println(s);
        }
    }

               
            2.StringBuffer 变为 String
                所有类都存在有 toString() 方法，利用此方法可以将 StringBuffer内容变为 String

    package cn.mysterious.study3;

    public class StringBufferClass {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            StringBuffer s = new StringBuffer("Hello");
            String str = s.toString();
            System.out.println(str);
        }
    }

               
                利用“+”实现所有数据类型向String的转换

    package cn.mysterious.study3;

    public class StringBufferClass {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            StringBuffer s = new StringBuffer("Hello");
            String str = "" + s;
            System.out.println(str);
        }
    }

               
        虽然在开发之中要进行字符串的操作都是以String类为主，可是你永远不要忽略一点： StringBuffer 类也提供有一些好的操作方法方便用户
        
        范例：在自定位置追加新的内容
            方法： public StringBuffer insert(int offset,数据类型 变量)

package cn.mysterious.study3;

public class StringBufferClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StringBuffer s = new StringBuffer("Hello");
        s.insert(5, "!!!");
        System.out.println(s);
    }
}

           
        范例：反转
            方法： public StringBuffer reverse()

package cn.mysterious.study3;

public class StringBufferClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StringBuffer s = new StringBuffer("Hello");
        System.out.println(s.reverse());
    }
}

           
        范例：删除指定范围的数据
            方法：public StringBuffer delete(int start,int end)

package cn.mysterious.study3;

public class StringBufferClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StringBuffer s = new StringBuffer("Hello! World!");
        s.delete(6, 12);
        System.out.println(s);
    }
}

           
        以上的 三个操作方法是掌握 StringBuffer 类的主要操作
        
        StringBuffer 类在 JDK1.0 的时候提供的，而在JDK1.5之后有提供了一个 StringBuilder 类，这两个类单看文档都一样
        StringBuffer 属于线程安全的操作，但是性能不高，而StringBuilder属于非线程安全的操作，性能高
        
        面试题：请解释 StringBuffer,StringBuilder,String 类的区别？
            String 类的内容一旦声明则不可改变，而 StringBuilder和StringBufffer的内容可以改变
            StringBuffer,StringBuilder,String 都属于 CharSequence 接口的子类
            StringBufffer 是从JDK1.0提供的，属于线程安全的操作，而StringBuilder 是从JDK1.5之后提供的，属于非线程安全的操作

    总结：
        字符串的操作首选的一定是 String类，可改变的时候再选择 StringBuffer,StringBuilder 多个线程访问同一资源时必须使用 StringBuffer

    
    Runtime 类
        Runtime 类的设计特点
        Runtime 类的使用
        
        在每个java进程之中都会存在有一个 Runtime 类的对象
        由于此类的对象是由java进程自己维护，所以在整个 Runtime 类设计的过程之中，只为用户提供了唯一的一个实例化对象，所以这个类所使用的是单例设计模式构造方法被私有化了
        所以其类的内部一定会提供有一个 static 方法取得本类的实例化对象
            取得 Runtime 类对象： public static Runtime getRuntime()
        那么取得对象之后可以做什么呢？
        在 Runtime 类中定义有如下可以取得内存大小的方法
            空闲内存大小： public long freeMemory()
            最大可用内存大小： public long maxMemory()
            总共可用内存大小： public long totalMemory()
        
        范例：取得内存空间大小

package cn.mysterious.study3;

public class RuntimeClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Runtime run = Runtime.getRuntime(); // 取得 Runtime 类的实例化对象
        System.out.println("MAX = " + run.maxMemory());
        System.out.println("TOTAL = " + run.totalMemory());
        System.out.println("FREE = " + run.freeMemory());
    }

}
/*
    结果：
        MAX = 937951232
        TOTAL = 64487424
        FREE = 63144784
*/

                   
        面试题：java如何调整可用内容的大小？
            
            java中的划分主要有两个组成部分：
                堆内存：保存的实例化对象的内容，每个JVM进程之中，对象的堆内存空间都会由垃圾收集器自动的管理内存回收问题
                非堆内存（ Eden + Front Space + To Space）：主要用于产生新的对象
                    所有方法的全局方法区
                    所有的 static 的全局数据区
                    永生代：负责存放反射对象的操作空间
                    
            如果要想调整内存大小主要调整的就是堆内存空间，它的调整有如下三个参数：
                -Xms ：初始分配大小，为物理内存的1/64，最多不超过1G
                -Xmx ：最大分配内存，为物理内存的1/4
                -Xmn ：年轻代堆内存大小
                
        范例：设置参数
            java -Xms1024M -Xmx1024M -Xmn521M ？？？(这里是文件的名称)
            
            
        在 Runtime 类中提供有垃圾的收集机制： public void gc()
        
        范例：垃圾回收

package cn.mysterious.study3;

public class RuntimeClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Runtime run = Runtime.getRuntime(); // 取得 Runtime 类的实例化对象
        System.out.println("1.MAX = " + run.maxMemory());
        System.out.println("1.TOTAL = " + run.totalMemory());
        System.out.println("1.FREE = " + run.freeMemory());
        String str = " ";
        for (int i = 0; i < 2000; i++) {
            str += i;
        }
        System.out.println("2.MAX = " + run.maxMemory());
        System.out.println("2.TOTAL = " + run.totalMemory());
        System.out.println("2.FREE = " + run.freeMemory());
        run.gc(); // 执行垃圾收集
        System.out.println("3.MAX = " + run.maxMemory());
        System.out.println("3.TOTAL = " + run.totalMemory());
        System.out.println("3.FREE = " + run.freeMemory());
    }

}

           
        那么回收到底经历过哪些问题呢？
            
            简单点说：
                新的对象保存在Eden区中，之后此对象保存在年轻代区；而后在进行GC 之后所有被保留下来的年轻代中的对象（从GC，MinorGC），将保存在旧生代（主GC，Majo）
                如果再有新的对象，从年轻代回收，在找到旧生代，最后都没有空间了，进行垃圾的全部扫描（Full GC）
                    
        面试题：请问什么是GC？如何操作？
            GC指的是垃圾收集，对于GC操作利用利用 Runtime 类中的 gc() 方法手工释放，或者是利用系统自动进行释放
                
                
    总结
        Runtime 使用了单例设计模式，每个JVM进程只会存在有一个 Runtime 类对象
        Runtime 了提供有 gc() 方法，可以进行垃圾收集处理


    System 类
        System 类的基本使用
        内存释放操作
        
        说到System 类一定会首先想到两个方法：
            输出：System.out.println()
            数组拷贝：System.arraycopy()
                完整定义： public static void arraycopy(Object src, int srcPos,Object dest, int destPos,int length)
            
        在System 类中定义有取得当前日期时间的方法： public static long currentTimeMillis()
        
        范例：利用此方法实现操作花费的时间内的统计

package cn.mysterious.study3;

public class SystemClass {

    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        long stasrt = System.currentTimeMillis();
        Thread.sleep(2000);
        long end = System.currentTimeMillis();
        System.out.println("计算花费时间：" + (end - stasrt));
    }

}

           
        但是在 System 类中定义有这样的一个方法： public static void gc() ，但是这个方法并不是实现的新的方法，而是继续调用了 Runtime 类中的 gc() 方法
        在新的对象实例化的时候可以利用构造方法进行相应的处理操作，但是在某一个对象回收之后，那么该如何在回收前给他一些处理的机会呢？
        在 Object 类中提供有一个对象回收前的释放操作：
            方法：  protected void finalize() throws Throwable
        此处可以抛出 Error 或 Exception ，但是不管抛出谁，最终都一定要被回收
        
        范例：观察对象回收

package cn.mysterious.study3;
class person{
    public void Person(){
        System.out.println("降临！");
    }
    @Override
    protected void finalize() throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("挂了！");
        throw new Exception("再活500年！");
    }
}
public class SystemClass {

    public static void main(String[] args) throws InterruptedException {
        person per = new person();
        per = null;
        System.gc();
    }

}

           
        面试题：请解释 final finally finalize 的区别？
            final ：定义不能够被继承的父类，不能够被子类所覆盖的方法，定义常量
            finally ：是在异常处理中进行异常处理的统一出口
            finalize ：是 Object 类的一个方法（ protected void finalize() throw Throwable ），是在对象回收前进行对象收尾操作的
            
    总结：
        System.currentTimeMillis();
        gc 永远只有一个方法，在 Runtime 类中定义的
        
        
    对象克隆
        克隆的操作实现
        
        写代码的过程之中很少能够见到这样的操作
        对象克隆指的就是复制对象，在 Object 类中提供有一个对象克隆的操作：
            方法： protected Object clone()throws CloneNotSupportedException
                由于所有的类对象都可能出现克隆的情况，所以此方法的返回值是 Object
                protected 只能够在同一包或不同包的子类中访问
                克隆方法会抛出一个异常，如果要克隆对象所在的类没有实现 Cloneable 接口，那么会抛出此异常
                
        但是打开 Cloneable 接口之后会发现，在这个接口里面没有定义任何的操作方法，因为它是一个标识接口，表示一种能力
        
        范例：实现克隆操作

package cn.mysterious.study3;
class Person implements Cloneable{ // 表示本类对象可以克隆
    private String name;
    private int age;
    public Person(String name,int age){
        this.name  = name;
        this.age = age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "姓名：" + this.name + "，年龄：" + this.age;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone(); // 调用父类中的方法
    }
}

public class SystemClass {

    public static void main(String[] args) throws Exception {
        Person per1 = new Person("林",15);
        Person per2 = (Person) per1.clone();
        per2.setAge(20);
        System.out.println(per1);
        System.out.println(per2);
    }

}

           
            对象考虑的关键是在于 Cloneable 接口的使用
        
    总结：
        标识接口的最大特征在于表示一种能力，而不会定义方法
        protected 权限