华清远见嵌入式学习day43——Java集合与IO操作

回顾：
抽象类:
 抽象类里可以有抽象方法和非抽象
 有抽象方法的类必须定义成抽象类
 
 抽象方法是要求具体子类必须重写的内容
 
接口：
接口的成员：
 成员只能是静态常量
 成员方法：
  抽象方法
  静态方法
  默认修饰的方法
 类和类：
 类和接口：多实现
    还可以继承一个类后再实现接口
接口和接口 ：
    多继承
-内部类
    成员内部类
    静态内部类
    局部内部类
    匿名内部类
匿名内部类经常使用的时候被当作参数传递
匿名内部类：
    实质是一个重写了接口中的抽象方法的
            具体类的对象
            
    异常：
    error：内存溢出不需要处理
    Exception：分两大类
     运行时期异常：自己改代码
     非运行时期异常：
      处理异常的方式
      1：捕获
      2:抛出
常用类：
Math：
String类：
 一组不能被改变的字符序列
  String s = “hello”；
  String s2 = “java”；
  System.out.print(s2+s);
  
思考 ：  
    String s = “hello”；
    String s2 = “hello”；
  System.out.print(s==s2); //地址值是一样的
  
  String s3 = new String（“hello”）；
    String s4 = new String（“hello”）；
  System.out.print(s3==s4);//false
 
 s和s3的区别：
 s创建了一个对象
 s3创建了两个对象 堆里一个 常量池
 
常用类 集合  线程 io
常用类：
-------------------------------
package com.hqyj.demo;
/**
 * StringBuffer()  
 *  线程安全的可变字符序列
 * 创建一个空的字符缓冲，长度为16个字符容量；
StringBuffer(int capacity) 用指定的初始容量创建一个空的字符缓冲；
StringBuffer(String  initString) 创建包含initString的字符缓冲，并加上16个字符的备用空间
 * 
  StringBuilder的方法是线程不安全的， 并发访问会出异常 执行效率高
    单线程的时候  
    eg：新闻项目 
    StringBuffer的方法是线程安全的 ，并发访问不出异常
    多线程：
    eg： 银行系统
    
 买票案例：
  100张票
  三个窗口卖：
  
 
  
 * @author zj
 *
 */
public class StringBufferDemo {

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("hello");
        sb.insert(1, "java");
        //反转
        sb.reverse();
        System.out.println(sb.length());//长度
        System.out.println(sb.capacity());//缓冲区
        System.out.println(sb);// 看的是sb里的内容
    }
}
-----------------------------------------------
集合：存储对象的
Collection接口：
        里面的集合有有序的有无序的
            分可重复 不可重复
list接口：有序可以重复的集合接口
  子类：ArrayList集合 
Set接口： 无序可以不重复的集合接口

打印一个对象的名
--------------------------------
    //打印一个对象的名 其实打印的是toString方法
        Object obj = new Object();
        //Object obj2 = new Object();
        System.out.println(obj);//java.lang.Object@15db9742
        System.out.println(obj.toString());//java.lang.Object@15db9742
        //String 里重写了toString方法  导致我打印的时候显示的是我string里的内容
        String s = new String("hello");
        System.out.println(s);
        System.out.println(s.toString());
------------------------------------------
list子类
Vector：底层是数组 增删慢 查询快 线程安全的可变字符序列
ArrayList：
底层是数组 增删慢 查询快 线程不安全
LinkedList：
底层是链表 增删快 查询慢 
-------------集合特有遍历方式-----------
package com.hqyj.demo;

import java.util.Iterator;
import java.util.Vector;

/**
 * 遍历集合
 * @author zj
 *
 */
public class VectorDemo {
    public static void main(String[] args) { //两种遍历方式  练习到11：45
        Vector v = new Vector();
        v.add("hello1");
        v.add("hello2");
        v.add("hello3");
        //把索引位置的元素换成指定元素
        v.set(1, "java");
        //遍历
//        for(int i =0; i<v.size();i++) {
//            System.out.println(v.get(i));
//        }
        //集合特有遍历方式 迭代器遍历  迭代器依赖于集合存在
        //创建迭代器对象 Iterator 
        Iterator it = v.iterator();
        //使用while
        while(it.hasNext()) {
            Object obj = it.next();
            
            System.out.println(obj);
        }
//        System.out.println(it.hasNext());
//        System.out.println(it.next());
//        System.out.println(it.hasNext());
//        System.out.println(it.next());
//        System.out.println(it.hasNext());
//        System.out.println(it.next());
//        System.out.println(it.hasNext());
        

        
        
    }

}
-------------------------------------------
引入泛型的代码
----------------------------------------------

package com.hqyj.demo;

import java.util.Iterator;
import java.util.Vector;

/**
 * 测试  集合中添加元素
 * 
 * @author zj
 *
 */
public class VectorDemo3 {
    public static void main(String[] args) { 
        Vector v = new Vector();
        v.add("hello1");
        v.add("hello2");
        v.add("hello3");
        v.add(10);//其实这样的一个10 被自动装箱 转化成了引用数据类型
        //v.add(new Integer(10));
        
        //集合特有遍历方式 迭代器遍历  迭代器依赖于集合存在
        //创建迭代器对象 Iterator 
        Iterator it = v.iterator();
        //使用while
        while(it.hasNext()) {
            Object obj = it.next(); //就想使用string里特有方法
            //强制类型转化
            //会报错因为把Integer类型的数据转换成String 
            //这样感觉不好，我希望你再创建集合的时候
            //就限定我未来集合能存储的数据类型
            //像这个需求java中提供了泛型帮我实现了<E>
            String str = (String) obj;
            System.out.println(str+"----"+str.length());
        }

    }

}

---------------------------------------------------
带泛型的集合
---------------------------------------------------
package com.hqyj.demo;

import java.util.Iterator;
import java.util.Vector;

/**
 * 添加泛型的集合
 * 泛型<E>: 存储的是引用数据类型   
 * @author zj
 */
public class VectorDemo4 {
    public static void main(String[] args) { 
        Vector<String> v = new Vector<String>(); //13:40
        v.add("hello1");
        v.add("hello2");
        v.add("hello3");
    //    v.add(10);//其实这样的一个10 被自动装箱 转化成了引用数据类型
        //v.add(new Integer(10));
        //集合特有遍历方式 迭代器遍历  迭代器依赖于集合存在
        //创建迭代器对象 Iterator 
        Iterator<String> it = v.iterator();
        //使用while
        while(it.hasNext()) {
            //就想使用string里特有方法
            String str = it.next();
            //强制类型转化
            //会报错因为把Integer类型的数据转换成String 
            //这样感觉不好，我希望你再创建集合的时候
            //就限定我未来集合能存储的数据类型
            //像这个需求java中提供了泛型帮我实现了<E>
            System.out.println(str+"----"+str.length());
        }

    }

}
------------------------------------------------------

            
--------------------------------------
IO 分类：
 1：按照流向分：
    输入流    读
    输出流    写
    
2：按照字节和字符分
    字节流：mp3 图片使用字节流
        字节输入流：InputStream
        字节输出流：OutputStream
    字符流：文本使用字符流
        字符输入流：reader
        字符输出流：writer
        
使用输出流子类
        字节输出流：OutputStream
        FileOutputStream
    输出流：
-------------------------------------------------
package com.hqyj.demo2;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 字节输出流
 *  write()
 *  wirte(byte[] a)
 * @author zj
 *
 */
public class FrleOutputStreamDemo {

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("fos.txt");
        //写文件   
        //一次写一个字节
        //fos.write(97);
        //一次写一个字节数组
        //fos.write("hello".getBytes());
        //一次写一个字节数组一部分
        byte [] bys = {97,98,99,100,101};
        fos.write(bys, 0, 3); //从指定位置写到len的位置 不包含len
        //关闭流
        fos.close();
        
    }

}
------------------------------------------------------
FileInputStream 一次读取一个字节数字
------------------------------------------------------
package com.hqyj.demo2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * 读入：
 *  read 
 *  读到最后的时候会返回一个-1
 * @author zj
 *
 */
public class FileInputStreamDemo {

    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("fos.txt");
        //第一次读
//        int ch = fis.read();
//        System.out.println((char)ch);
//        //第二次
//        int ch1 = fis.read();
//        System.out.println((char)ch1);
//        //第3次
//        int ch2 = fis.read();
//        System.out.println((char)ch2);
        //因为代码重复  使用循环改进 while
//        int ch = fis.read();
//        while(ch != -1) {
//            System.out.println((char)ch);
//            ch = fis.read();
//        }
        int ch =0;
        while( (ch =fis.read()) != -1) {
            System.out.println((char)ch);
        }
        //关闭流  =
        fis.close(); //写一下 写道15：15
    }

}

--------------------------------------------------------
FileInputStream 一次读取一个字节数字    
--------------------------------------------------
package com.hqyj.demo2;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * 一次读取一个字节数组
 * @author zj
 */
public class FileInputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("fos.txt");
//        int len = fis.read(bys);
//        System.out.println(len);
//        //String里有一个构造方法可以把字符数组转换成字符串
//        //System.out.println(new String(bys));
//        System.out.println(new String(bys,0,len));
//        //第二次读
//        len = fis.read(bys);
//        System.out.println(len);
//        //String里有一个构造方法可以把字符数组转换成字符串
//        //System.out.println(new String(bys));
//        System.out.println(new String(bys,0,len));
//        
//        //第3次读
//        len = fis.read(bys);
//        System.out.println(len);
//        //String里有一个构造方法可以把字符数组转换成字符串
//        //System.out.println(new String(bys));
//        System.out.println(new String(bys,0,len));
//        //第4次读
//        len = fis.read(bys);
//        System.out.println(len);
//        //String里有一个构造方法可以把字符数组转换成字符串
//        //System.out.println(new String(bys));
//        System.out.println(new String(bys,0,len));
        //循环改进  使用while
        byte []bys =new byte[5]; //练习到16：05
        int len = 0;
        while( (len =fis.read(bys)) !=-1) {
            System.out.print(new String(bys,0,len));
        }
    }
}
----------------------------------------------------------

copy文件
----------------------------------------------
package com.hqyj.demo3;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 拷贝FrleOutputStreamDemo.java内容
 * 到fos.txt
 * @author zj
 *
 */
public class CopyDemo {
//练习到 两种copy方式 1 16：25
    public static void main(String[] args) throws IOException {
        //读的对象
        FileInputStream fis = new FileInputStream("FrleOutputStreamDemo.java");
        //写的对象
        FileOutputStream fos = new FileOutputStream("fos.txt");
        //边读边写
        //一次读取一个字节的写法
//        int by = 0;
//        while((by = fis.read()) !=-1) {
//            fos.write(by);
//        }
        //一次读取一个字节数组的写法
        byte [] by = new byte[1024];
        int len = 0;
        while((len = fis.read(by)) !=-1) {
            fos.write(by, 0, len);
        }
            fis.close();
            fos.close();
    }
}        
-----------------------------------------        
线程：
开启两种方式：
1：1:自定义类继承字Thread
 *  2：再该类里重写run方法
 *  3:再测试类里创建 自定义类的对象
 *  4:开启线程 strat()
2：种类：
 1：自定义类实现Runable接口
 2：：重写run方法
 3：再测试类里创建Thread对象把自定义类对象当作参数传递
 4：开启线程 strat()
----------------------------------------
package com.hqyj.demo4;
/** 1:自定义类继承字Thread
 *  2：再该类里重写run方法
 *  3:再测试类里创建 自定义类的对象
 *  4:开启线程 strat()
 *  
 * @author zj
 */
public class TreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start(); //开启线程 //开启线程后帮我执行run方法
    }
}
----------------------------------------
package com.hqyj.demo4;

public class MyThread extends Thread{
    //run 方法里封装了线程执行的代码
    @Override
    public void run() {
        for(int i= 0; i<100; i++) {
            System.out.println("i: "+i);
            
        }
    }

}
-------------------------------------