一、对象流
- 先序列化，后反序列化
- 输入写出的顺序必须一致
- 不是所有的类都能够序列化 实现接口java.io.Serializable
- 不是所有的属性都需要序列化 transient
- 如果父类实现了序列化接口，子类中所有的内容都与能力序列化
- 如果子类实现了序列化接口，但是父类没有实现，子类只能序列化自己的内容
- 静态的内容不能序列化
public class ObjectDemo {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
out("D://lalala.txt");
in("D://lalala.txt");
}
//序列化输出流
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();
}
}
class Person implements Serializable{
private static int id;
private String name;
private transient int age;
public Person() {
// TODO Auto-generated constructor stub
}
public Person(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}
二、容器
容器概念：可变长的,任意数据类型的数据的集合
数组：1、定长的；2、数据类型相同；3、有序，有索引，根据索引查询效率高
1、手写简单容器
自定义容器类：只存储字符串，实现随着内容的增删长度可变
//自定义容器类
class MyContainer{
private String[] arr=null;
//容器中数据的个数
private int size;
public MyContainer() {
arr=new String[0];
}
/*
* 修改功能
*/
public void change(int index,String str) {
if(index<0 || index>=size){
throw new ArrayIndexOutOfBoundsException("索引越界啦!!!");
}
//修改元素
arr[index] = str;
}
/*
* 根据索引删除数据
*/
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
容器可以存储任意类型的数据
泛型中的数据类型只能为引用类型，基本数据类型会发生自动装箱
2.1遍历
1）、增强for
//增强for
for(Object o : col){
System.out.println(o);
}
2）、迭代器
//迭代器
//1.获取操作这个容器的迭代器对象
Iterator it=col.iterator();
//2.判断下一个是否有数据
if(it.hasNext()){
//3.获取写一个数据
System.out.println(it.next());
}
2.2 泛型
泛型:
定义规范容器中所有元素的数据类型,强制规范,如果不符合报错
增强程序的稳定性和可读性
Collection<String> col3=new ArrayList();
col3.add("呵呵");
//col3.add(15);
3、List接口
有序的，可重复的
新增功能：增加了一些关于索引操作的方
3.1 List使用
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));
}
}
3.2 List接口遍历
1）、普通for
2）、for...each
3）、迭代器
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 & Vector
ArrayList 有序的可重复的
- 底层:数组实现,进行动态扩容,每次使用copyOf方法进行扩容,每次扩容后的容量是原容量的1.5倍(源码里可以看到)
- 优点:随机获取或者遍历效率高
- 缺点:增删效率低
- 线程不安全的,效率高
Vector 向量
- 底层:数组实现,使用copyOf方法进行动态扩容,每次扩容后的容量是原容量的2倍
- 线程安全的,效率低
5、LinkedList
- 底层:双向链表实现
- 优点:做增删效率高
- 缺点:查询和遍历效率低
- 新增功能: 新增了一些操作与头部和尾部的方法
单向链表实现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;
}
}
链表：
链表中包含数据和下一个节点的地址
节点（Node）：链表中的每一个元素都是一个节点
单向链表关注：链表头，这个链表结构中的第一个节点
双向链表关注：链表头和链表尾
6、Set 接口
无序的，不可重复
无序：放入数据的顺序和内部真实存储的顺序不一致，内部有自己的存储顺序，一旦确定了存储顺序，不会发生改变
Set set=new HashSet();
set.add(false);
set.add(true);
7、HashSet
- 底层:哈希表结构(数组+链表+红黑树)
- 优点:查询,添加,删除,修改效率高
- 缺点:无序
如果两个对象的hashcode值不相同,两个对象肯定不相同,如果值相同,可能不是相同对象,可以是相同对象
对对象类型数据进行去重:要重写hashCode和equals方法
先比较hashCode,如果值不同,不会调用equals方法,如果值相同才会调用equals方法
public class HashSet10 extends Object{
public static void main(String[] args) {
Set<String> set=new HashSet();
set.add("秋天");
set.add("春天");
set.add("冬天");
set.add("冬天");
set.add("冬天");
set.add("夏天");
System.out.println(set);
Set<Person> persons=new HashSet();
persons.add(new Person(10,"胡歌",35));
persons.add(new Person(11,"彭于晏",37));
persons.add(new Person(11,"彭于晏",37));
persons.add(new Person(12,"吴彦祖",40));
System.out.println(persons);
}
}
8、TreeSet
- 底层:红黑树
- 优点:升序排序
TreeSet tree=new TreeSet();
tree.add(13);
tree.add(5);