第十二章 集合框架(一)

1.IO流补充

1.1 IO流的分类

 1.2 练习

使用io流实现文件复制

public class Test {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("e:/Desktop/mu.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("e:/Desktop/wen1.txt"));
        String content;
        while ((content = br.readLine())!=null){
            bw.write(content);
        }
        bw.flush();
        bw.close();
        br.close();
    }
}

 1.3 IO流中的异常处理

public class Test {
    public static void main(String[] args){
        String srcPath = "e:/Desktop/wen.txt";
        String destPath = "e:/Desktop/mu.txt";

        InputStream is = null;
        OutputStream os = null;
        try{
            is = new FileInputStream(srcPath);
            os = new FileOutputStream(destPath);

            byte[] bs = new byte[1024];
            int count = -1;
            while (true){
                count = is.read(bs);
                if(count == -1){
                    break;
                }
                os.write(bs,0,count);
            }
        }catch (FileNotFoundException ex){
            //文件不存在异常
            ex.printStackTrace();
        }catch (IOException ex){
            //输入输出异常(读写文件异常)
            ex.printStackTrace();
        }finally {
            //确保流关闭的操作执行
            if(os!=null){
                try {
                    os.close();
                }catch (IOException ex){
                    ex.printStackTrace();
                }
            }
            if(is!=null){
                try{
                    is.close();
                }catch (IOException ex){
                    ex.printStackTrace();
                }
            }
        }

    }
}

 1.4 Properties文件的使用

        Java中的配置文件，格式为文本文件，文件的内容的格式是“键=值”或者“键 值”的格式。

①在src根目录下创建xx.properties文件;

②创建Properties类对象，加载 .properties 文件；

③访问属性文件中的键值对数据。

public class Test {
    public static void main(String[] args) throws IOException {
        //用当前类的类加载器加载属性文件，返回输入流
        InputStream is =  Test.class.getClassLoader().getResourceAsStream("stu.properties");
        System.out.println(is);
        //创建Properties对象(可以存储键值对数据)，处理properties文件
        Properties properties = new Properties();
        //加载数据流
        properties.load(is);
        //输出学生信息
        is.close();
        //properties.getProperty(键):根据键获取值
        System.out.println(properties.getProperty("name"));
        System.out.println(properties.getProperty("sex"));
        System.out.println(properties.getProperty("age"));
        System.out.println(properties.getProperty("tall"));
    }
}

2. 集合框架

2.1 概念

        Java集合框架(Java Collection Framework，简称JCF)是为了表示和操作集合，而规定的一种统一标准的体系结构；集合框架包含三大块内容：对外的接口、接口的实现和对集合运算的算法。

        集合就是用于存储对象的容器，只要是对象类型就可以存进集合框架中；集合的长度是可变的，泛型集合中不可以存储基本数据类型的值。

 2.2 集合和数组的区别

        数组和集合相比，数组的缺点是长度固定，不能动态扩展。

        集合存储数据时是没有长度限制的，可以动态扩展；集合容器因为内部的数据结构不同，有多种不同的容器对象，这些容器对象不断的向上抽取，就形成了集合框架。

3. Collection 接口

        Collection接口是单值集合的顶层接口

返回类型	方法名称	描述
boolean	add(Object o)	在集合末尾添加元素
int	size()	返回集合列表中元素个数
boolean	removeAll(Collection col)	删除集合中的所有元素
boolean	contains(Object o)	判断集合中是否存在指定的元素
boolean	remove(Object o)	从集合中删除元素
void	clear()	清除集合中的所有元素
Iterator	iterator()	为Iterator接口实例化

    public static void main(String[] args) {
        //定义Collection接口变量，指向集合实现类对象ArrayList
        Collection col = new ArrayList();
        // add向Collection集合末尾添加元素
        // 默认可以存储任何类型的数据
        // Collection允许数据重复，并且可以存null值
        // Collection 没有办法根据索引获取单个元素
        col.add("aaa");
        col.add("aaa");
        col.add(123);
        col.add(12.13);
        col.add(true);

        System.out.println(col);
        //foreach 遍历集合
        for (Object o : col) {
            System.out.println(o);
        }
        //判断元素是否存在
        col.contains(123);
        //删除元素
        col.remove(123);
        System.out.println(col);
        
        //删除集合中的所有元素
        Collection col2 = new ArrayList();
        col2.add("aaa");
        col2.add(12.13);

        col.removeAll(col2);
        System.out.println(col);
        //删除集合中的所有元素
        col.clear();
        System.out.println(col);
    }

4. List接口及其实现类

4.1 特点

①List集合是有序集合: 数据的添加和存储次序一致；

②List集合可以存储重复的数据；

③List集合中的数据可以通过下标访问。

 

返回类型	方法名称	描述
boolean	add(Object o)	在集合末尾添加元素
int	size()	返回集合列表中元素个数
Object	get(int index)	返回指定索引位置的元素，索引从0开始
boolean	removeAll(Collection col)	删除集合中的所有元素
boolean	contains(Object o)	判断集合中是否存在指定元素
boolean	remove(Object o)	从集合中删除元素
Object	remove(int index)	从集合中删除指定索引位置的元素

4.2 ArrayList实现类

特点:

①实现了List接口；

②可以动态扩容(长度不够,底层会自动的扩容）；

③通过下标可以快速访问数据；

④查找快，插入删除慢；

⑤ArrayList底层是数组，对数组做了封装；

⑥可以存储任意类型的数据，包括null；

⑦数据按照存储次序排列；

⑧数据可以重复；

⑨多线程访问时不安全。

ArrayList的创建和使用

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add(123);
        list.add(12.13);
        list.add(true);
        list.add(new Student("小成","男",19));

        System.out.println(list);
        System.out.println(list.get(6));

        list.remove("bbb");
        //Object obj = 123;
        //list.remove(obj);
        // 123 会被当作下标索引
        list.remove(123);
        list.remove(new Integer(123));
        System.out.println(list);

        list.remove(new Student("小成","男",19));
        System.out.println(list);
    }
}

public class Student {
    String name;
    String sex;
    int age;

    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object obj){
        System.out.println("====重写equals===");
        if(this == obj){
            return true;
        }
        if(obj instanceof Student){
            Student student = (Student) obj;
            if(student.toString().equals(this.toString())){
                return true;
            }
        }
        return false;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, sex, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

4.3 LinkedList 实现类

public class Test {
    public static void main(String[] args) {
        //链表:1.查询效率低 2.添加删除效率高
        LinkedList list = new LinkedList();
        list.add("aaa");
        list.add("ccc");
        list.add("ddd");
        list.add(100);
        list.add(300);
        list.add(200);
        System.out.println(list);
        list.addFirst("xxxx"); //头部添加
        list.addLast("yyyy"); //尾部添加
        System.out.println(list);
        list.add(3,"qqq");
        System.out.println(list);
        list.removeLast(); //删除尾部
        list.removeFirst();//删除头部
        System.out.println(list);

        System.out.println("=================");
        //Vector:多线程环境下安全，性能低。
        //ArrayList:多线程环境下不安全，性能高
        Vector vector = new Vector();
        vector.add("sdfs");
        vector.add("asdf");
        vector.add(2423);
        vector.add(true);
        vector.add(null);
        System.out.println(vector);
    }
}