一、对象流
对象流 序列化 公共流(节点流)
ObjectInputStream 反序列化输入流 新增方法 readObject()
ObjectOutputStream 序列化输出流 新增方法 writeObject()
注意:
先序列化后反序列化
输入写出的顺序必须一致
不是所有的类都能够序列化 实现接口java.io.Serializable
不是所有的属性都需要序列化 transient
如果父类实现了序列化接口,子类中所有的内容都与能力序列化
如果子类实现了序列化接口,但是父类没有实现,子类只能序列化自己的内容
静态的内容不能序列化
public static void write(String dest,ArrayList<Student> stu) throws FileNotFoundException, IOException {
ObjectOutputStream oos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
for(int i=0;i<stu.size();i++) {
System.out.println(stu.get(i));
oos.writeObject(stu.get(i));
}
oos.close();
}
public static boolean read(String src,int size) throws FileNotFoundException, IOException, ClassNotFoundException {
ObjectInputStream ois=new ObjectInputStream(new BufferedInputStream(new FileInputStream(src)));
ArrayList<Student> stu=null;
for(int i=0;i<size;i++) {
if("李凯".equals(((Student)(ois.readObject())).getName()))
return true;
}
ois.close();
return false;
}
二、、容器： 可变长的,任意数据类型的数据的集合
1、数组:
定长的
数据类型相同
有序,有索引,根据索引查询效率高
缺点：数组长度一旦确定，不可改变，因此，不灵活：容量需要事先定义好，不能随 着需求的变化而扩容。
2、容器类
数组远远不能满足我们的需求。我们需要一种灵活的，容量可以随时扩充的容 器来装载我们的对象。这就是容器类，或者叫集合框架。
手写简单容器:
自定义容器类 : 只存储字符串,实现随着内容的增删长度可变
class MyContainer{
private String[] arr=null;
private int size;
public MyContainer() {
arr=new String[0];
}
public String getArr(int index) {
if(index<0||index>=size) {
throw new ArrayIndexOutOfBoundsException();
}
return arr[index];
}
public int getSize() {
return size;
}
/*
* 修改功能
*/
//添加
public void add(String str) {
String[] temp=arr;
arr=new String[size+1];
for(int i=0;i<size;i++) {
arr[i]=temp[i];
}
arr[size]=str;
size++;
}
//删除
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 < temp.length; i++) {
if(i<=index) {
if(i==index)
continue;
arr[i]=temp[i];
}else {
arr[i-1]=temp[i];
}
}
size--;
}
}
3、集合 Collection
成员方法:
注意：
容器可以存储任意类型的数据
泛型中的数据类型只能为引用类型,基本数据类型会发生非自动装箱
遍历:
增强for
迭代器
Collection col1 = new ArrayList();
Collection col2 = new ArrayList();
Collection<String> col3 = new ArrayList();
col1.add("123");
col1.add("567");
// boolean isEmpty() 如果此 collection 不包含元素，则返回 true。
System.out.println(col2.isEmpty());
// boolean addAll(Collection<? extends E> c)
// 将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
col2.addAll(col1);
System.out.println(col2);
// boolean contains(Object o)如果此 collection 包含指定的元素，则返回 true。
System.out.println(col1.contains("123"));
// void clear() 移除此 collection 中的所有元素（可选操作）。
col1.clear();
System.out.println(col1.isEmpty());
// removeAll(Collection)
//移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
System.out.println(col2.removeAll(col1));
System.out.println(col2);
// int size() 返回此 collection 中的元素数。
System.out.println(col1.size());
// Object[] toArray() 返回包含此 collection 中所有元素的数组。
Object[] a = col1.toArray();
System.out.println(Arrays.toString(a));
//迭代器
Iterator it = col2.iterator();
if(it.hasNext()){
System.out.println(it.next());
}
//增强for
for(Object o:col2)
System.out.println(o);
4、 List接口：有序的,可重复的
新增功能:新增了一些关于索引操作的方法
接口遍历:
for普通for
for .. each
迭代器
List<String> list=new ArrayList();
list.add("钢铁侠");
list.add("雷神");
list.add("鹰眼");
list.add("快银");
list.add("浩克");
list.add("美国队长");
list.add("洛基");
list.add("灭霸");
System.out.println(list);
//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));
boolean flag=false;
for(int i=0;i<list.size();i++) {
if(list.get(i).equals("灭霸")) {
list.add("惊奇队长");
}
}
System.out.println(list);
for(String str:list) {
if(str.equals("灭霸")) {
flag=true;
}
}
if(flag) {
list.add("惊奇队长");
flag=false;
}
System.out.println(list);
for(Iterator it=list.iterator();it.hasNext();) {
if(it.next().equals("灭霸"))
flag=true;
}
if(flag) {
list.add("惊奇队长");
}
System.out.println(list);
5、ArrayList ：有序的可重复的
底层:数组实现,进行动态扩容,每次使用copyOf方法进行扩容,每次扩容后的容量是原容量的1.5倍
优点:随机获取或者遍历效率高
缺点:增删效率低
线程不安全的,效率高
Vector： 向量
底层:数组实现,使用copyOf方法进行动态扩容,每次扩容后的容量是原容量的2倍
线程安全的,效率低
ArrayList<Person> al=new ArrayList<>();
al.add(new Person(1,"大锤",108));
System.out.println(al);
System.out.println(al.indexOf(new Person(1,"大锤",108)));
6、LinkedList
底层:双向链表实现
优点:做增删效率高
缺点:查询和遍历效率低
新增功能: 新增了一些操作与头部和尾部的方法
LinkedList<String> ls=new LinkedList<String>();
ls.add("小明");
ls.add("小黄");
ls.add("小花");
System.out.println(ls);
//void addFirst(E e) 将指定元素插入此列表的开头。
// void addLast(E e) 将指定元素添加到此列表的结尾。
ls.addFirst("1");
ls.addLast("0");
System.out.println(ls);
// E element() 获取但不移除此列表的头（第一个元素）。
System.out.println(ls.element());
自定义LinkedList容器类(单向链表)
public class LinkedList05 {
public static void main(String[] args) {
//Test for MyLinkdeList
MylinkedList myll=new MylinkedList();
myll.add("assassin");
myll.add("sabor");
myll.add("berserker");
myll.add("lancer");
System.out.println(myll.getSize());
System.out.println(myll.get(3));
}
}
//自定义LinkedList容器类
class MylinkedList{
//链表头
private Node head;
//链表长度
private int size;
//constructor
public MylinkedList() {}
//获取长度
public int getSize() {
return size;
}
//获取第index个数据
public String get(int index) {
Node temp=head;
for (int i = 0; i < size; i++) {
if(i==index) {
return temp.getData();
}else {
temp=temp.getAddress();
}
}
return null;
}
//添加元素
public void add(String str) {
//先创建一个新节点
Node newNode=new Node(str,null);
if(head==null) {
head=newNode;
size++;
}else {
Node temp=head;
for (int i = 0; i < size; i++) {
if(temp.getAddress()==null) {
temp.setAddress(newNode);
}else {
temp=temp.getAddress();
}
}
size++;
}
}
}
//节点类，模拟单向链表，存储数据和地址
class Node{
private String data;
private Node address;
public Node() { }
public Node(String data, Node address) {
super();
this.data = data;
this.address = address;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public Node getAddress() {
return address;
}
public void setAddress(Node address) {
this.address = address;
}
}
7、 Set 接口
无序的 不可重复
放入数据的顺序和内部真实存储的顺序不一致,内部有自己的存储顺序,一旦确定了存储顺序不会发生改变
Set set=new HashSet();
set.add(1);
set.add(true);
set.add("qwer");
System.out.println(set);
//运行结果[1, qwer, true]
8、HashSet
底层:哈希表结构(数组+链表+红黑树)
优点:查询,添加,删除,修改效率高
缺点:无序
注意：
如果两个对象的hashcode值不相同,两个对象肯定不相同,如果值相同,可能不是相同对象,可以是相同对象
HashSet<Person> hs=new HashSet<Person>();
hs.add(new Person(1,"张三",10));
hs.add(new Person(3,"赵四",22));
hs.add(new Person(3,"赵四",22));
System.out.println(hs);
//结果：
//[Person [id=3, name=二锅头, age=18],
//Person [id=3, name=赵四, age=22],
// Person [id=3, name=赵四, age=22]]
对对象类型数据进行去重:要重写hashCode和equals方法
先比较hashCode,如果值不同,不会调用equals方法,如果值相同才会调用equals方法
//重写hashCode和equals方法后运行结果：
//[Person [id=3, name=二锅头, age=18],
// Person [id=3, name=赵四, age=22]]
9、TreeSet
底层:红黑树
优点:升序排序
存放具有可比性的引用类型数据
TreeSet<Integer> ts=new TreeSet<Integer>();
ts.add(1);
ts.add(2);
ts.add(3);
System.out.println(ts);
TreeSet要求加入的所有元素都可以相互比较大小;可以控制比较位置来决定排序方向；hashset只能比较可相等不能比较大小
可以通过元素本身的类实现Comparable来自我解决
@Override
public int compareTo(Object o) {
if(this.id==((Person)o).getId()) {
return 0;
}else if (this.id>((Person)o).getId()) {
return -1;
}else {
return 1;
}
}
重写之后可以使用自定义对象Person
TreeSet<Person> tsp=new TreeSet<Person>();
tsp.add(new Person(1,"张三",10));
tsp.add(new Person(3,"赵四",22));
tsp.add(new Person(3,"赵四",22));
System.out.println(tsp);
三、Map
1、Map
实现Map接口的类用来存储键(key)－值(value) 对。
Map类中存储的键－值对通过键来标识，所以键值不能重复。
键值对：
存储的数据都是key,value键值对形式的，二者之间为映射关系
key 可以任意数据类型 无序的,唯一的 -->set结合
value 可以任意数据类型 无序的 ,不唯一的 -->Collection结合
一个key只能对应一个value(value可以为集合,集合中存储多个数据)
使用：
Map<String, Integer> map=new HashMap();
//添加元素 map.put("胡歌", 30);
map.put("胡歌", 28);//重复元素会覆盖，因为是按键值判断
map.put("刘德华", 50);
System.out.println(map);
//V get(Object key)
System.out.println(map.get("胡歌"));
//boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
//boolean containsValue(Object value)
System.out.println(map.containsKey("胡歌"));
//remove(key) System.out.println(map.remove("胡歌"));
运行结果
{刘德华=50, 胡歌=28} 28 true 28
2、HashMap
HashSet是由HashMap维护的,但是HashMap是键值对的形式,初始容量是16,加载因子是0.75
底层是hash表的结构
HashMap的key如果是引用数据类型的对象,做去重要重写hashCode和equals
如果想要实现value去重,需要手动判断
HashMap<Person, Integer> hashmap=new HashMap();
hashmap.put(new Person(1,"赵",20),01);
hashmap.put(new Person(2,"钱",22),3); System.out.println(hashmap);
3、TreeMap
TreeSet是由TreeMap的key维护的,使用方式相同,但是是键值对的形式
//创建TreeMap对象 TreeMap<Person,Integer> tm1=new TreeMap();
//或调用有参构造器，传入比较器 TreeMap<Person,Integer> tm2=new TreeMap((o1,o2)->(((Person)o1).getAge()-((Person)o2).getAge()); tm1.put(new Person(1,"赵",20),01); tm2.put(new Person(2,"钱",22),3);
4、Properties
HashTable的子类，key和value都是string
Properties pp=new Properties(); // void load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。 pp.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties01")); System.out.println(pp.stringPropertyNames());
四、注意点：
1、继承关系：Collection，Set，List，Map都是接口，不能实例化，使用其实现类创建对象
2、ConcurrentModificationException 当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
网友评论