容器
在学习容器之前不从一下昨天讲的IO流中的一个对象流。
一、对象流
1. 对象流 序列化 公共流(节点流)
2.主要用到的方法：ObjectInputStream，反序列化输入流，新增方法 readObject()；ObjectOutputStream ，序列化输出流，新增方法writeObject()。
3.编码示例：
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
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 + "]";
}
}
4.解析：对象流主要用来序列化的，在设置属性是必须设置成私有的（private修饰的），需要提供公共的访问模式，需要提供get和setter设置器，因为要有返回值，所以需要重写tostring方法.执行步骤和文件拷贝相似,这里就不一一详细介绍了.
5.注意要点: 先序列化后反序列化;输入写出的顺序必须一致;不是所有的类都能够序列化,实现接口java.io.Serializable;不是所有的属性都需要序列化transient;如果父类实现了序列化接口,子类中所有的内容都与能力序列化;如果子类实现了序列化接口,但是父类没有实现,子类只能序列化自己的内容;静态的内容不能序列化.
二.容器类
1. 容器: 可变长的,任意数据类型的数据的集合.
2.示例: 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;
}
}
三. 集合 Collection
1.容器可以存储任意类型的数据;泛型中的数据类型只能为引用类型,基本数据类型会发生非自动装箱.
2.关于Collection的方法示例: 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));
3.遍历(1).增强for;
(2)迭代器://迭代器
//1.获取操作这个容器的迭代器对象
Iterator it=col.iterator();
//2.判断下一个是否有数据
if(it.hasNext()){
//3.获取写一个数据
System.out.println(it.next());
}
(3). 泛型:定义规范容器中所有元素的数据类型,强制规范,如果不符合报错; 作用: 增强程序的稳定性和可读性; Collection<String> col3=new ArrayList();
col3.add("呵呵");
<>中写数据类型,基本类型鄙俗经过自动装箱才能使用
四.List接口 有序的,可重复的,新增功能:新增了一些关于索引操作的方法.
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));
}
}
2关于遍历在list类的中的应用示例:
(1)import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
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());
}
}
}
(2). import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;public class Test05 {
public static void main(String[] args) {
List<String> list=new ArrayList();
list.add("钢铁侠");
list.add("黑寡妇");
list.add("灭霸");
list.add("美国队长");
list.add("蜘蛛侠");
System.out.println(list);
/*//普通for
for(int i=0;i<list.size();i++){
if("灭霸".equals(list.get(i))){
list.add("惊奇队长"); //添加在最后
}
}
System.out.println(list); */
//增强for ConcurrentModificationException 当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
/*for(String s:list){
if("灭霸".equals(s)){
list.add("惊奇队长"); //添加在最后
}
}
System.out.println(list); */
//迭代器 ConcurrentModificationException
//1)获取迭代器对象
/*Iterator it=list.iterator();
while(it.hasNext()){
if("灭霸".equals(it.next())){
list.add("惊奇队长"); //添加在最后
}
}*/
//ListIterator<E> listIterator() 列表迭代器
ListIterator<String> ls=list.listIterator();
while(ls.hasNext()){
if("灭霸".equals(ls.next())){
ls.add("惊奇队长"); //添加在最后
}
}
System.out.println(list);
}
}
五. LinkedList类
1.特点:底层:双向链表实现;优点:做增删效率高;缺点:查询和遍历效率低;新增功能: 新增了一些操作与头部和尾部的方法
2.关于linkedlist类一些方法的应用示例;
(1).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);
}
}
(2). 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;
}
}
六. ArrayList类
1.特点: ArrayList 有序的可重复的;底层:数组实现,进行动态扩容,每次使用copyOf方法进行扩容,每次扩容后的容量是原容量的1.5倍;优点:随机获取或者遍历效率高;缺点:增删效率低;线程不安全的,效率高
2. Vector 向量
底层:数组实现,使用copyOf方法进行动态扩容,每次扩容后的容量是原容量的2倍;线程安全的,效率低
3.示例:
import java.io.Serializable;
import java.util.ArrayList;
public class ArrayList06 {
public static void main(String[] args) {
ArrayList<Person> a=new ArrayList();
a.add(new Person(01,"赵坤朋",20));
a.add(new Person(02,"锡纸烫",18));
a.add(new Person(03,"小姐姐",19));
System.out.println(a);
System.out.println(a.indexOf(new Person(03,"小姐姐",19))); //-1
}
}
class Person{
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 + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
七. HashSet类
1.特点: 底层:哈希表结构(数组+链表+红黑树);优点:查询,添加,删除,修改效率高;缺点:无序;如果两个对象的hashcode值不相同,两个对象肯定不相同,如果值相同,可能不是相同对象,可以是相同对象;对对象类型数据进行去重:要重写hashCode和equals方法;先比较hashCode,如果值不同,不会调用equals方法,如果值相同才会调用equals方法
2.示例:
import java.util.HashSet;
import java.util.Set;
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);
}
}
八. Set 接口
1.特点: 无序的 不可重复;放入数据的顺序和内部真实存储的顺序不一致,内部有自己的存储顺序,一旦确定了存储顺序不会发生改变
2.示例:
import java.util.HashSet;
import java.util.Set;
public class Set09 {
public static void main(String[] args) {
Set set=new HashSet();
set.add(false);
set.add(true);
set.add(false);
set.add(true);
set.add(null);
set.add(null);
System.out.println(set);
System.out.println(set);
System.out.println(set.contains(false));
}
}
九,TreeSet类
1.特点: 底层:红黑树;优点:升序排序
2. public class TreeSet10 {
public static void main(String[] args) {
TreeSet tree=new TreeSet();
tree.add(13);
tree.add(5);
tree.add(7);
tree.add(7);
tree.add(7);
tree.add(9);
System.out.println(tree);
}
}