Java一些特性的示例代码_java简单特性的例子-CSDN博客

本文链接：https://blog.csdn.net/axzywan/article/details/5826804

package test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;

public class example {

    public static void main(String args[]) {
        try {
            example test = new example();
            test.hashCodeEqualTest();
            test.serializableTest();
            test.cloneTest();
            test.compareTest();
            String template = "abcd";
            String tempTemplate = template;
            tempTemplate = "bbbbbbb";
            System.out.println(template);
            System.out.println(tempTemplate);
        } catch (Exception e) {
            System.out.println(e);
        }
    }

    //java中的序列化(serialization)机制能够将一个实例对象的状态信息写入到一个字节流中，使其可以通过socket进行传输、或者持久化存储到数据库或文件系统中；
    //然后在需要的时候，可以根据字节流中的信息来重构一个相同的对象。序列化机制在java中有着广泛的应用，EJB、RMI等技术都是以此为基础的。
    //序列化机制是通过java.io.ObjectOutputStream类和java.io.ObjectInputStream类来实现的。
    //在序列化(serialize)一个对象的时候，会先实例化一个ObjectOutputStream对象，然后调用其writeObject()方法；
    //在反序列化(deserialize)的时候，则会实例化一个ObjectInputStream对象，然后调用其readObject()方法。
    private void serializableTest() throws Exception {
        Person p = new Person("liuwei", 23);
        System.out.println(p);
        // 序列化。谁为ObjectOutputStream对象实例化就向哪里输出
        ObjectOutputStream oos = null;
        oos = new ObjectOutputStream(new FileOutputStream(new File("c://123.txt")));
        oos.writeObject(p);

        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("c://123.txt")));
        Person p1 = (Person) ois.readObject();
        System.out.println(p1);
        ois.close();
        oos.close();
    }

    private void hashCodeEqualTest() {
        Map m=new HashMap();

        m.put(new Person02("zhansan",30),"zhansan");
        m.put(new Person02("zhansan",20),"zhansan");

        //如果不覆写equals和 HashCode方法的话是不能查找的到的
        System.out.println(m.get(new Person02("zhansan",30)));
        System.out.println(m.get(new Person02("zhansan",10)));
        Person02 p1 = new Person02("zhansan",30);
        Person02 p2 = new Person02("zhansan",10);
        if (p1.equals(p2)) {
            System.out.println("equals");
            System.out.println(p1.hashCode());
            System.out.println(p2.hashCode());
        } else {
            System.out.println("not equals");
            System.out.println(p1.hashCode());
            System.out.println(p2.hashCode());
        }
    }

    private void cloneTest() throws Exception {
        Person03 p=new Person03("zhansan",12);
        Person03 p2=(Person03) p.clone();
        p2.name="lisi";

        System.out.println(p);
        System.out.println(p2);
    }

    private void compareTest() {
        Person5 p[] = new Person5[6];
        p[0] = new Person5("张三",20,96);
        p[1] = new Person5("李四",19,96);
        p[2] = new Person5("钱八",19,97);
        p[3] = new Person5("赵六",21,78);
        p[4] = new Person5("孙七",20,80);
        p[5] = new Person5("王五",19,97);
        Arrays.sort(p) ;
        for(int i=0;i<p.length;i++)
        {
         System.out.println(p[i]) ;
        }
        System.out.println("------------------------") ;
        //如果把compareTo方法除掉，则会包类型转换异常java.lang.ClassCastException
        Set s = new TreeSet() ;
        s.add(new Person5("钱八",19,97));
        s.add(new Person5("张三",20,96));
        s.add(new Person5("李四",19,96));
        s.add(new Person5("王五",19,97));
        s.add(new Person5("赵六",21,78));
        s.add(new Person5("孙七",20,80));

        Iterator iter = s.iterator();
        while(iter.hasNext()){
         System.out.println(iter.next());
        }
    }
}

//对象序列化
//对象序列化是指把对象写入到流中，对象的反序列化是指从流中恢复对象
//其优点是：即使程序运行结束，对象仍然可以保存下来。必须实现Serializable接口
//一个类想实现序列号，必须实现Serializable接口
//此接口只是一个声明接口，表示实现此接口的类可以被实例化
//如果某个属性不要求进行序列化，则用关键字transient。
class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    // private int age;
    // 如果某个属性不要求进行序列化
    private transient int age;

public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    public String toString() {
        return this.name + " " + this.age;
    }
}
//HashCode方法，JAVA中的对象都有自身的HashCode码
class Person02 {
    private String name;
    private int age;

    public Person02(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "姓名：" + this.name + "年龄：" + this.age;
    }

    //复写equals 和 HashCode 方法
    //HashCode 方更多的是表示对象的地址
    public boolean equals(Object obj) {
        if (this.hashCode() == obj.hashCode()) {
            return true;
        }
        return false;
    }

    public int hashCode() {
        return this.name.hashCode() + this.age * 1000;
    }
}

//克隆方法的使用,必须实现Cloneable接口
//而且必须覆写Object类的clone方法
//protected Object clone()throws CloneNotSupportedException
//Cloneable也是一个标识接口。类似于Serializable
class Person03 implements Cloneable {
    public String name;
    private int age;

    public Person03(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "姓名：" + this.name + " 年龄：" + this.age;
    }

    //扩大父类的权限为公共的
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 比较器：Array类是一个专门用于数组排序的，可以对任何数据进行排序
// 对象排序的内容必须实现Comparable接口，覆写compareTo方法定义规则
// 还可以用在TreeSet上实际上TreeSet也需要比较器的支持
class Person5 implements Comparable {
    private String name;
    private float score;
    private int age;

    public Person5(String name, int age, float score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String toString() {
        return "姓名：" + this.name + " 年龄：" + this.age + "分数" + this.score;
    }

    @Override
    public int compareTo(Object obj) {
        Person5 p = (Person5) obj;
        if (p.score > this.score) {
            return 1;
        } else if (p.score < this.score) {
            return -1;
        } else {
            // 如果成绩相等则判断年龄
            if (p.age > this.age) {
                return 1;
            } else if (p.age < this.age) {
                return -1;
            } else {
                return 0;
            }
        }
    }
}