序列化,泛型

序列化：ObjectOutputStream

用于对象的输出writeObject（），保存对象的各项信息

反序列化：ObjectInputStream

用于对象的读取readObject（）把之前序列化输出的数据，在程序中重新恢复成对象

注意：

1.如果一个类的对象想要被序列化，那么这个类必须实现可序列化接口

2.必须先序列化，再反序列化，并且一次序列化对应一次反序列化

3.反序列化时的文件路径必须与序列化时的文件路径一致

4.反序列化时持有的UID必须与序列化目标类Student中的UID一样，否则报销。

package cn.tedu.serializable;
import java.io.*;
/**
 * 序列化：ObjectOutputStreaam：把java对象，保存在磁盘中，相当于对象信息写出保存在文件中
 * 反序列化：ObjectInputStream 把之前序列化输出的数据读到内存程序中，相当于把对象读取到程序中
 * 推荐大家:一次序列化操作对应一次反序列化操作
 */
public class TestSerializable {
    public static void main(String[] args) {
        method1();//序列化
        method2();//反序列化
    }

    private static void method2() {
        ObjectInputStream in=null;
        try{
            //3.创建反序列化输入流
            in=new ObjectInputStream(new FileInputStream("D:\\ready\\1.txt"));
            Object o = in.readObject();
            System.out.println(o);
            System.out.println("恭喜您！反序列化成功！");
        }catch(Exception e){
            System.out.println("很抱歉，反序列化失败！");
            e.printStackTrace();
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 注意：序列化输出的数据我们是看不懂的
     * 我们需要后期通过反序列技术把之前输出的数据重新恢复成对象，才能使用
     */
    private static void method1() {
        ObjectOutputStream out=null;
        try{
            out=new   ObjectOutputStream(new FileOutputStream("D:\\ready\\1.txt"));
            Student obj=new   Student("海绵宝宝",3,"海里",'男');
            out.writeObject(obj);
            System.out.println("恭喜您！序列化成功！");
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("很抱歉！序列化失败！");
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}


package cn.tedu.serializable;

import java.io.Serializable;

/**
 * 如果本类的对象想要被序列化输出，必须实现可序列化接口Serializable
 * 否则会报错
 * Serializable是一个空接口，里面一个方法都没有
 * 作用是用作标志，标记这个类的对象可以被序列化
 */
public class Student implements Serializable {
    /***
     * JVM会给每个要序列化输出的类分配一个唯一的UID
     * 只要更改了这个类，自动生成的默认UID就会改变
     */
    //这是我们手动提供的，写死了的UID数据，永远都是1L,但是不推荐这么写
    //private static final long serialVersionUID=1L;
        private String name;
        private int age;
        private String addr;
        private  char gender;

    public Student() {
        System.out.println("我是Student的无参构造");
    }

    public Student(String name, int age, String addr, char gender) {
        this.name = name;
        this.age = age;
        this.addr = addr;
        this.gender = gender;
        System.out.println("我是Student的有参构造");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", addr='" + addr + '\'' +
                ", gender=" + gender +
                '}';
    }
}

泛型：

package cn.tedu.generic;

import java.util.ArrayList;
import java.util.List;

/**
 * 本类用于测试泛型的优点
 * 泛型怎么来的？----想要模拟数组的类型检查
 * 数组的好处：在编译器就会检查数据类型，如果不是数组规定的类型，就报错
 */
public class TestGeneric1 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("涛涛");
        list.add(1);
        list.add(8.8);
        list.add('v');
        System.out.println(list);

        /**
         * 泛型通常与集合一起使用，用来约束集合中元素的类型
         * 泛型的好处：可以来约束集合数据类型，把报错的时机提前，而不是运行的时候才报错。
         * 在向集合中添加元素时，会先检查元素的数据类型，不是要求的类型就编译失败
         */
        List<String> list2=new ArrayList();
        list2.add("霞霞");
//        list2.add(1);

        /**
         * /*4.<type>--type的值应该如何写?
         * * 这个需要根据自己的业务自定义,但是type必须是引用类型,不能是基本类型
         * * 如果想写基本类型,就写基本类型对应的包装类型*/
        List<Integer> list3=new ArrayList();
        list3.add(100);
        list3.add(200);
        list3.add(300);
        list3.add(400);
        System.out.println( list3);


    }

}
[涛涛, 1, 8.8, v]
[100, 200, 300, 400]

package cn.tedu.generic;

/*本类用于测试泛型的优点2*/
public class TestGeneric2 {
    public static void main(String[] args) {
        Integer[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        print(a);
        String[] b = {"大哥", "二哥", "三哥", "四哥", "五哥", "六哥", "小弟"};
        print(b);
        Double[] c = {6.0, 6.6, 6.66, 6.666, 6.6666};
        print(c);
    }

    /*1.泛型可以实现通用代码的编写,使用E表示元素的类型是Element元素
     * 2.泛型的语法要求:如果在方法上使用泛型,必须两处同时出现
     * 一个是传入参数的类型为泛型,一个是返回值前的泛型类型,表示这是一个泛型方法*/
    private static <E> void print(E[] a) {
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }
    }


//    private static void print2(Double[] c) {
//        for (int i = 0; i < c.length; i++) {
//            System.out.println(c[i]);
//        }
//    }
//
//    private static void print1(String[] b) {
//        for (int i = 0; i < b.length; i++) {
//            System.out.println(b[i]);
//        }
//    }
//
//    private static void print(Integer[] a) {
//        for (int i = 0; i <= a.length - 1; i++) {
//            System.out.println(a[i]);
//        }
//    }
}
1
2
3
4
5
6
7
8
9
10
大哥
二哥
三哥
四哥
五哥
六哥
小弟
6.0
6.6
6.66
6.666
6.6666

高效for循环

 /*高效for循环/foreach循环:
         * 好处: 比普通for循环写法简单,而且效率高
         * 坏处：没有办法按照下标来操作值，只能从头到尾依次遍历所有数据
         * 语法: for(1 2 : 3 ){循环体}
         * 3-要遍历的数据 1-每轮遍历到的数据的类型 2-变量名,可以随意起*/
        for(E S:a){
            System.out.println(a);
        }