JAVA语言学习-Day5

集合

Java中的集合是工具类，可以存储任意数量的具有共同属性的对象

应用场景

1. 无法预测存储数据的数据

2. 同时存储具有一对一关系的数据

3. 需要进行数据的增删

4. 数据重复问题

体系结构

• Collection：List、Queue、Set

• Map：HashMap

List

有序且可重复，ArrayList、LinkedList

• ArrayList底层是由数组实现的

• 动态增长

• 在列表尾部插入或删除数据非常有效

• 更适合查找和更新元素

• ArrayList中的元素可以为null

方法

List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.size();//列表中元素个数
list.get(0);//获取第一个元素
list.remove(0);//移除第一个元素
list.remove("aaa");//移除元素"aaa"

Set

元素无序并且不可以重复的集合，被称为集

HashSet

• HashSet是Set的一个重要实现类，被称为哈希集

• HashSet中的元素无序并且不可以重复

• HashSet中只允许有一个null元素

• 具有良好的存取和查找性能

Iterator(迭代器)

HashSet a = new HashSet();
a.add("a");
a.add("b");
//插入重复数据，失败但不会报错
Iterator i = a.iterator();
while(i.hasNext()) {
    System.out.println(i.next());
}

Map

• Map中的数据是以键值对（key-value）的形式存储的

• key-value是以Entry类型的对象实例存在的

• 可以通过key值快速的查找value

• 一个映射不能包含重复的键

• 每个键最多只能映射到一个值

HashMap

• 基于哈希表的Map接口实现

• 允许使用null值和null键

• key值不允许重复

• HashMap中的Entry对象是无序排列的

线程

进程是指可执行程序并存放在计算机存储器的一个指令序列，它是一个动态执行的过程

线程的创建

1. 创建一个Thread类，或者一个Thread子类的对象

2. 创建一个Runnable接口的类的对象

• Java为线程提供10个优先级，默认为5，数字越大优先级越高

• 优先级常量也可用来表示：

  • MAX_PRIORITY:线程的最高优先级10

  • MIN_PRIORITY:线程的最低优先级1

  • NORM_PRIORITY:线程的默认优先级5

class MyThread extends Thread{
    private String name;
    public MyThread(){}
    public MyThread(String name){
        super(name);
        this.name = name;
    }
    @Override
    public void run(){
        System.out.println(getName+"该线程正在执行");
    }
}
class PrintRunnable implements Runnable{
    @Override
    public void run(){
        try{
            Thread.sleep(1000);//线程中止1000毫秒
        }catch(e){e.printStackTrace();}
        System.out.println(Thread.currentThread().getName()+"正在运行");
    }
}
public static void main(String[] args){
    Thread.currentThread().getPriority();//获取当前线程优先级，主线程优先级
    MyThread mt = new MyThread();
    MyThread mt1 = new MyThread("线程一");
   
    mt.setPriority(10);//设置线程优先级
   
    mt.start();//启动线程，只能一次
    mt1.start();
    try{
        System.out.printlnt("线程mt的优先级"+mt.getPriority());
        mt.join(1000);//抢占资源，优先执行1000毫秒
    }catch(e){
        e.printStackTrace();
    }
    System.out.println("主线程执行");
    
    PrintRunnable pr = new PrintRunnable();
    Thread t1 = new Thread(pr);
    t1.start();
}

线程的状态

新建、可运行（就绪）、运行、阻塞、终止

synchronized关键字

synchronize关键字用在

• 成员方法

• 静态方法

• 语句块

I/O流

文件可认为是相关记录或放在一起的数据的集合

常用方法

File f1 = new File("C:\\");
File f2 = new File(f1,"url");
f1.isDirectory();//判断是否是目录
f1.isFile();//判断是否是文件
​
f1.Absolute();//判断是否绝对路径
f1.getPath();//获取相对路径
f1.getAbsolutePath();//获取绝对路径
f1.getName();//获取文件名
​
if(!f1.exists){//判断目录不存在
    f1.mkdir();//创建目录
    f1.mkdirs();//创建多级目录
    try{
        f2.createNewFile();
    }catch(IOException e){
        e.printStackTrace();
    }
}

• 绝对路径:从盘符开始的路径

• 相对路径:从当前路径开始的路径

字节流

1. 字节输入流

   • InputStream

     • FileInputStream：文件输入流

     • PipedInputStream：管道输入流

     • FilterInputStream：过滤器输入流

       • PushbackInputStream：回压输入流

       • BufferedInputStream：缓冲输入流

       • DataInputStream：数据输入流

     • ObjectInputStream：对象输入流

     • SequenceInputStream：顺序输入流

     • ByteArrayInputStream：字节数组输入流

     • StringBufferInputStream：缓冲字符输入流

2. 字节输出流

   • OutputStream

     • FileOutputStream：文件输出流

     • PipedOutputStream：管道输出流

     • FilterOutputStream：过滤器输出流

       • PrintStream：格式化输出流

       • BufferedOutputStream：缓冲输出流

       • DataOutputStream：数据输出流

     • ObjectOutputStream：对象输出流

     • ByteArrayOutputStream：字节数组输出流

//FileInputStream 返回值-1表示达到文件末尾
FileInputStream fis = new FileInputStream(url);
int n = 0;//读取文件
while((n=fis.read())!=-1){
    System.out.print((char)n);
}
byte[] b = new byte[100];
fis.read(b);
System.out.print(new String(b));
​
fis.close();

//FileOutputStream
FileOutputStream fops = new FileOutputStream(url,true);//true追加内容，不覆盖
fops.write(50);
fops.write("a");
​
fops.close();

缓冲流

• 缓冲输入流：BufferedInputStream

• 缓冲输出流：BufferedOutputStream

FileOutputStream fos = new FileOutputStream(url);
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write(50);
bos.write("a");
bos.flush();
​
FileInputStream fis = new FileInputStream(url);
BufferedInputStream bis = new BufferedInputStream(fis);
bis.read();
(char)bis.read();
​
fos.close();
bos.close();
fis.close();
bis.close();

字符流

• 字符输入流Reader

  1. BufferedReader - LineNumberReader

  2. CharArrayReader

  3. StringReader

  4. InputStreamReader - FileReader

  5. PipedReader

  6. FilterReader - PushbackReader

• 字符输出流Writer

  1. BufferedWriter

  2. CharArrayWriter

  3. StringWriter

  4. OutputStreamWriter - FileWriter

  5. PipedWriter

  6. FilterWriter

• 字符缓冲输入流：BufferedReader

• 字符缓冲输出流：BufferedWriter

//字节字符转换流
FileInputStream fis = new FileInputStream(url);
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
BufferedReader br = new BufferedReader(isr);
int n = 0;
char[] c = new char[10];
while((n=isr.read())!=-1){
    System.out.print((char)n);
}
while(n=isr.read(c)!=-1){
    String s = new String(c,0,n);
    System.out.print(s);
}
​
FileOutputStream fos = new FileOutputStream(url);
OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
while(n=isr.read(c)!=-1){
    osw.write(c,0,n); //字符输出流
    osw.fluse();
}
while(n=br.read(c)!=-1){//字符缓冲流读
    bw.write(c,0,n); //字符缓冲流写
    bw.fluse();
}
​
fis.close();
isr.close();
br.close();
fos.close();
osw.close();
bw.close();

对象的序列化和反序列化

序列化：把java对象转换为字节序列的过程

反序列化：把字节序列恢复为java对象的过程

• 创建一个类，继承Serializable接口

• 创建对象，将对象写入文件

• 从文件读取对象信息

  • 对象输入流ObjectInputStream

  • 对象输出流ObjectOutputStream

public class Obj1 implements Serializable{}//对象类继承接口
Obj1 obj = new Obj1("","",100);//构造方法创建对象
FileOutputStream fos = new FileOutputStream(url);//创建输出文件对象
ObjectOutputStream oos = new ObjectOutputStream(fos);//创建输出流对象
oos.writeObject(obj);//将对象写入文件，实现持久化存储
oos.flush();
​
FileInputStream fis = new FileInputStream(url);
ObjectInputStream ois = new ObjectInputStream(fis); 
obj obj_1 = (obj)ois.readObject();
​
fos.close();
oos.close();
fis.close();
ois.close();