JavaSE.20190509.对象流.容器（一）.泛型

一.对象流

     1.对象流       序列化     公共流（节点流）

        ObjectInputStream       反序列化输入流        新增方法   readObject()

        ObjectOutputStream    序列化输入流           新增方法   writeObject()

     2.注意：

        1）先序列化后反序列化

        2）输入写出的顺序必须一致

        3）不是所有的类都能够序列化        实现接口 java,io.Serializable

        4）不是所有的属性都需要序列化   transient

        5）如果父类实现了序列化接口，子类中所有的内容都与能力序列化

        6）如果子类实现了序列化接口，但是父类没有实现，子类只能序列化自己的内容

        7）静态的内容不能序列化

//序列化输出流
	public static void out(String dest) throws FileNotFoundException, IOException{
		//选择流  建立联系
		ObjectOutputStream os=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
		//准备数据
		Person p=new Person(01,"李四",80);
		//写出
		os.writeObject(p);
		//关闭 +输出
		os.close();
		
		p.setId(100);
		p.setName("hahahahha");
	} 
	
	//反序列化输入流
	public static void in(String src) throws FileNotFoundException, IOException, ClassNotFoundException{
		//选择流  建立联系
		ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(src)));
		//写出
		Object o=is.readObject();
		if(o instanceof Person){
			Person p=(Person)o;
			System.out.println(p.getId());
			System.out.println(p.getName());
			System.out.println(p.getAge());
		}
		//关闭
		is.close();
	} 
}

二.容器（一）

     1.容器与数组：

        容器：可变长的，任意数据类型的数据的集合

        数组：定长的，数据类型相同，有序有索引，根据索引查询效率高

        手写简单容器：

                             自定义容器类：只存储字符串，实现随着内容的增删长度可变

public class App01 {
	public static void main(String[] args) {
		MyContainer my=new MyContainer();
		//存储数据
		my.add("惊奇队长");
		my.add("美国队长");
		System.out.println(my.get(0));;
		System.out.println(my.get(1));;
		System.out.println(my.getSize());
		//删除元素 根据索引删除
		my.remove(0);
		System.out.println(my.get(0));;
		System.out.println(my.getSize());
	}
}
//自定义容器类
class MyContainer{
	private String[] arr=null;
	//容器中数据的个数
	private int size;
	public MyContainer() {
		arr=new String[0];
	}
	/*
	 * 修改功能
	 */
	/*
	 * 根据索引删除数据
	 */
	public void remove(int index) {
		if(index<0 || index>=size){
			throw new ArrayIndexOutOfBoundsException("索引越界啦!!!");
		}
		//存储原数组
		String[] temp=arr;
		arr=new String[size-1];
		//拷贝
		for(int i=0;i<size;i++){
			if(i>=index){
				if(i==index){
					continue;
				}else{
					arr[i-1]=temp[i];
				}
			}else{
				arr[i]=temp[i];
			}
		}
		size--;
	}
	/*
	 * 根据索引进行获取 
	 */
	public String get(int index) {
		if(index<0 || index>=size){
			throw new ArrayIndexOutOfBoundsException("索引越界啦!!!");
		}
		return arr[index];
	}
	/*
	 * 添加方法
	 * 	每次添加一个数据,数组进行扩容
	 */
	public void add(String ele) {
		//存储原数组中的数据
		String[] temp=arr;
		arr=new String[size+1];
		//数组拷贝
		for(int i=0;i<size;i++){
			arr[i]=temp[i];
		}
		arr[size]=ele;
		size++;
	}
	//外部获取容器中数据的长度
	public int getSize() {
		return size;
	}
}

 

     2.集合 Collection
        成员方法:
                      容器可以存储任意类型的数据
                      泛型中的数据类型只能为引用类型,基本数据类型会发生非自动装箱
        遍历:1.曾强for      2.迭代器
        泛型 :定义规范容器中所有元素的数据类型,强制规范,如果不符合报错

public class CollectionDemo02 {
	public static void main(String[] args) {
		Collection col=new ArrayList();
		Collection col2=new ArrayList();
		//boolean add(E e) 
		col.add("哈哈");
		col.add(123);
		col.add("hehe");
		col.add("hengheng");
		col2.addAll(col);
		System.out.println(col);
		System.out.println(col2);
		//void clear() 移除此 collection 中的所有元素（可选操作）。 
		//col2.clear();
		System.out.println(col2);
        //boolean contains(Object o)如果此 collection 包含指定的元素，则返回 true。 
		System.out.println(col.contains("哈哈"));
		
		//equals
		System.out.println(col.equals(col2));  //比较内容,有重写
		
		//boolean isEmpty() 如果此 collection 不包含元素，则返回 true。 
		System.out.println(col2.isEmpty());
		//boolean remove(Object o) 
		System.out.println(col.remove("哈哈"));
		System.out.println(col);
		//removeAll(Collection)
		System.out.println(col2.removeAll(col));
		System.out.println(col2);
		
		//int size()  返回此 collection 中的元素数。 
		System.out.println(col.size());
		//Object[] toArray() 返回包含此 collection 中所有元素的数组。 
		col.toArray();
		Object[] a=col.toArray();
		System.out.println(Arrays.toString(a));
		
		//增强for
		for(Object o : col){
			System.out.println(o);
		}
		
		//迭代器
		//1.获取操作这个容器的迭代器对象
		Iterator it=col.iterator();
		//2.判断下一个是否有数据
		if(it.hasNext()){
			//3.获取写一个数据
			System.out.println(it.next());
		}
		
		//增强程序的稳定性和可读性
		//泛型  :定义规范容器中所有元素的数据类型,强制规范,如果不符合报错
		Collection<String> col3=new ArrayList();
		col3.add("呵呵");
//		col3.add(15);
	}
}

       3.List接口
          1）有序的,可重复的
          2）新增功能:新增了一些关于索引操作的方法

public class ListDemo03 {
	public static void main(String[] args) {
		List<Integer> list=new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		list.add(3, 333);
		System.out.println(list);
		list.set(3, 000);
		System.out.println(list);
		
		//E get(int index)  
		System.out.println(list.get(2));
		//remove(ele|index) 如果数据和索引都是整数,默认把参数认为index
		list.remove(3);
		System.out.println(list);
		
		//List<E> subList(int fromIndex, int toIndex)    toIndex取不到
		System.out.println(list.subList(1, 3));
		
	}
}

          4）List接口遍历:
               ①for普通for
               ②for .. each
               ③迭代器

public class ListDemo04 {
	public static void main(String[] args) {
		List<Integer> list=new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		
		//普通for
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i)); 
		}
		
		//增强for
		for(Integer i:list){
			System.out.println(i);
		}
		
		//迭代器
		//1)获取迭代器对象
		for(Iterator it=list.iterator();it.hasNext();){
			System.out.println(it.next());
		}
		
	}
}

       4.ArrayList 有序的可重复的
          底层:数组实现,进行动态扩容,每次使用copyOf方法进行扩容,每次扩容后的容量是原容量的1.5倍
          优点:随机获取或者遍历效率高
          缺点:增删效率低
                   线程不安全的,效率高
       5.Vector 向量
          底层:数组实现,使用copyOf方法进行动态扩容,每次扩容后的容量是原容量的2倍
          线程安全的,效率低

       6.LinkedList 
          底层:双向链表实现
          优点:做增删效率高
          缺点:查询和遍历效率低
          新增功能: 新增了一些操作与头部和尾部的方法

public class LinkedList07 {
	public static void main(String[] args) {
		LinkedList list=new LinkedList();
		list.add("哈哈");
		list.add("呵呵");
		list.add("嘿嘿");
		System.out.println(list);
		
		/*
		 * void addFirst(E e) 
		          将指定元素插入此列表的开头。 
		   void addLast(E e) 
		          将指定元素添加到此列表的结尾。 
		 */
		list.addFirst("1");
		list.addLast("0");
		System.out.println(list);
		
		// E element()  获取但不移除此列表的头（第一个元素）。 
		System.out.println(list.element());
		System.out.println(list);
	}
}

       7.单向链表实现LinkedList类

public class LinkedList08 {
	public static void main(String[] args) {
		MyLinkedList my=new MyLinkedList();
		my.add("hehe");
		my.add("haha");
		System.out.println(my.size());
		System.out.println(my.get(0));
		System.out.println(my.get(1));
	}
}
//自定义LinkedList容器类
class MyLinkedList{
	//链表头
	private Node head;
	//长度
	private int size;
	
	public MyLinkedList() {
		// TODO Auto-generated constructor stub
	}
	
	public String get(int index) {
		Node temp=head;
		
		for(int i=0;i<size;i++){
			if(i==index){
				return temp.getData();
			}else{
				temp=temp.getText();
			}
		}
		return null;
	}

	//add(元素) 添加元素
	public void add(String str){
		//1.创建一个新节点
		Node newNode=new Node(str,null);
		//2.把新节点挂在原链表的最后
		//如果当前新节点是这个链表结构的第一个节点,就赋值为链表头
		if(head==null){
			head=newNode;
			size++;
		}else{
			//temp存储链表头节点
			Node temp=head;
			//循环遍历
			for(int i=0;i<size;i++){
				if(temp.getText()==null){
					temp.setText(newNode);
				}else{
					temp=temp.getText();
				}
			}
			size++;
		}
	}
	
	public int size(){
		return size;
	}
}

//节点类 Node
class Node{
	private String data;
	private Node text;
	
	public Node() {
		// TODO Auto-generated constructor stub
	}

	public Node(String data, Node text) {
		super();
		this.data = data;
		this.text = text;
	}

	public String getData() {
		return data;
	}

	public void setData(String data) {
		this.data = data;
	}

	public Node getText() {
		return text;
	}

	public void setText(Node text) {
		this.text = text;
	}
}