菜鸡的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("\n该学习了！");

    }

}

此时的执行结果之中发现字符串的内容已经得到了改变，所以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 权限

巴特西

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

最新文章

热门文章