【从头开始学JAVA】泛型 序列化与反序列化

泛型

"语法糖"

引入泛型-主要目的是想通过泛型来约束集合中的元素的类型
泛型的好处:可以把报错的时机提前,在编译器就报错,而不是运行后才抛出异常
在向集合中添加元素时,会先检查元素的书写类型,不是要求的类型就编译失败

<type>  --type的值应该如何写?
需要查看要存放的数据类型时什么,依据类型来定义
但是type必须是引用类型,不能是基本类型

如:List<String> list2 = new ArrayList<String>();

public class TestStudy <Student>{}
public interface Collection<E> {}
public <E> void print(E e){}
在方法的返回值前声明了一个<E>，表示后面出现的E是泛型而不是普通的java变量

 public static void main(String[] args) {
        Integer[] a ={1,2,3,4,5};
        
        String[] b= {"上","山","打","老","虎"};
        
        Double[] c={6.0,6.6,6.66,6.666};
        
        print(a);
        
    }
        /**泛型可以实现通用代码的编写,使用E表示元素是Element类型*/
        /**泛型的语法要求:如果在方法上使用泛型,必须两处同时出现
         * 一个是传入的参数的类型,另一个是方法声明上返回值类型之前的泛型*/
        private static <E> void print(E[] a) {
            for (E d :a) {
                System.out.println(d);
            }
        }
}

 

四种集合迭代方式

 

package cn.tedu.collection;

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

/**本类用于测试List的迭代*/
public class TestList2 {
    public static void main(String[] args) {
        //1.创建List接口对象
        List<String> list =new ArrayList<String>();

        //2.向集合中添加元素
        list.add("喜羊羊");
        list.add("美羊羊");
        list.add("沸羊羊");
        list.add("小肥羊");
        list.add("烤全羊");

        //3.测试集合的迭代
        /**集合的迭代方式
         * 1.for循环
         * 2.增强for循环/高效for循环/foreach循环
         * 3.iterator迭代器循环
         * */
        //方式一:因为List 集合是有序的,元素是有下标的,所以可以根据下标进行遍历
        for (int i = 0; i < list.size(); i++) {
            //根据下标获取集合中对应位置上的元素
            System.out.println(list.get(i));
        }
        System.out.println("*****以上方式一*******");

        //方式二:  1 2 : 3   , 3是要遍历的元素,2是遍历得到的元素类型,1是 遍历得到的元素名字
        for (String s :list) {
            System.out.println(s);
        }
        System.out.println("*****以上方式二*******");

        //方式三:通过集合对象的迭代器进行迭代
        /**1.获取指定集合的额迭代器*/
        Iterator<String> it =list.iterator();
        /**由于我们不知道集合有多少元素,所以用while循环遍历集合所有元素*/
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("*****以上方式三*******");

        //方式四:listIterator()是List接口独有的
        //listIterator是Iterator的子接口,可以拥有父接口的方法,还拥有自己独有的方法(逆序遍历)
        Iterator<String> it2 =list.listIterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
        System.out.println("*****以上方式四*******");


    }

}

 

序列化与反序列化

1.封装学生类

package cn.tedu.seri;

import java.io.Serializable;
/**本类如果想要实现序列化,必须实现可实现可序列化接口,否则报错
 * 报错信息:NotSerializableException:cn.tedu.seri.Student
 * Serializable是一个空接口,里面一个方法都没有,作用:当作标志,标志着这个类可以被序列化*/
/**本类用来封装学生类*/
public class Student implements Serializable {
    /**需要给每个进行序列化的文件分配唯一的UID值*/
    //private static final long serialVersionUID=1L;
    //1.定义并封装属性
    private  int sno;//学号
    private  String name;
    private  String address;
    private  char gender;//性别
    //2.提供无参构造--必须手动提供无参构造,否则会被全参覆盖
    public Student() {
        System.out.println("无参构造");
    }
    //3.生成全参构造
    public Student(int sno, String name, String address, char gender) {
        this.sno = sno;
        this.name = name;
        this.address = address;
        this.gender = gender;
        System.out.println("全参构造");
    }

    /**右键空白生成Getter and Setter 方法*/
    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
    /**打印结果:cn.tedu.seri.Student@677327b6
     * 想看*/
    @Override
    public String toString() {
        return "Student{" +
                "sno=" + sno +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", gender=" + gender +
                '}';
    }
}

 

2.测试序列化与反序列化

package cn.tedu.seri;

import java.io.*;

/**本类测试序列化与反序列化*/
public class TestSerializable {
    public static void main(String[] args) {
        //f();//测试序列化
        f2();//测试反序列化
    }

    /**序列化方法*/
    private static void f() {
        //声明在本方法中生效的序列化类型变量,局部变量需要初始化,本处指为null
        ObjectOutputStream out =null;
        try {
            //1.创建用来序列化的流对象OOS
            out=new ObjectOutputStream(new FileOutputStream("D:\\ready\\1.txt"));
            //2.创建要序列化的Student对象
            Student s =new Student(888,"泡泡","地球",'男');
            //3.通过OOS流对象来序列化对象输出到指定文件
            out.writeObject(s);
            System.out.println("序列化成功!");
        }catch (Exception e){
            System.out.println("序列化失败!");
            e.printStackTrace();//当捕获到异常,打印错误信息到控制台
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**反序列化方法*/
    private static void f2() {
        //声明在本方法中生效的序列化类型变量,局部变量需要初始化,本处指为null
        ObjectInputStream in=null;
        try {
            //1.获取反序列化大的流对象OIS
            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();
            }
        }

    }

}