javase(六)

io流

基本流

• 字符集

  • //编码
    变量名.getBytes(指定的字符集);//编码为当前代码的字符集进行编码
    //解码
    String st = new String(要解码的变量名,指定的字符集);
    

• 字节输入流:FileInputStream

  • //创建
    InputStream 对象名 = new FileInputStream(文件路径);
    //一个字节一个字节接收
    对象名.read();
    //每次读取一个字节数组返回
    对象名.read(字节数组名);//参数2,3为从哪读,读到哪
    //用数组接收,可以读完全部字节
    对象名.readAllBytes();
    

• 字节输出流:FileOutputStream

  • //创建
    OutputStream 对象名 = new FileOutputStream(文件路径);//参数2填true会保留上次的数据,否则会清空
    //一个字节一个字节写入
    对象名.write();
    //写一个字节数组
    对象名.write(字节数组名);
    //编码的形式写中文
    byte 数组名[] = 要写的中文.getBytes();
    

• 字符输入流::FileReader

  • //创建
    Reader 对象名 = new FileReader(文件路径);
    //一个字符一个字符接收
    对象名.read();
    //每次读取一个字符数组返回
    对象名.read(字符数组名);//参数2,3为从哪读,读到哪
    

• 资源释放

  • //tra,catch
    //jdk9优化:在try上面定义对象,try(对象名1,对象名2,可以自动释放资源,可以不写finally)
    try(//jdk7简化:在try(这里定义对象,可以自动释放资源,可以不写finally)){
    
    }catch(){
        
    }finally{
        
    }
    //finally:无论代码正常或者异常结束都会执行到finally大括号内的代码
    

  • //刷新数据
    对象名.flush();
    //关闭管道,自带刷新
    对象名.close()
    

• 字符输出流:

  • //创建
    Writer w = new FileWriter();//参数2填true会保留上次的数据,否则会清空
    //一个字符一个字符写入或写一个字符串
    对象名.write();
    //参数1为字符串,参数2为从哪里开始写,参数3为写到哪
    

缓冲流

• 字节缓冲流

  • 与基本流使用基本一致

    • 只需要把基本流的对象转为对应的缓冲流对象

    • //例
      OutputStream 缓冲流对象名 = new BufferedOutputStream(基本流对象名);
      

• 字符缓冲流

  • 与基本流使用基本一致

    • 只需要把基本流的对象转为对应的缓冲流对象

    • //例
      BufferedWriter 缓冲流对象名 = new BufferedWriter(基本流对象名);
      

    • //一行一行读
      对象名.readLine();
      //自带换行
      对象名.newLine();
      

转换流

• 字符输入转换流

  • //创建
    Reader 对象名 = new InputStreamReader(基本流文件,指定编码格式);
    

• 字符输出转换流

  • //创建
    Writer 对象名= new OutputStreamWriter(基本流文件,指定编码格式);
    

打印流

• printStream

  • //创建
    PrintStream 对象名 = new PrintStream(文件路径);
    

序列化

• 对象字节输出流

  • 必须实现Serializable接口

  • //创建
    ObjectOutputStream 对象名 = new ObjectOutputStream(new FileOutputStream(文件路径));
    //与创建基本流一致,只不过是写成一行代码
    

• 对象字节输入流

  • //创建
    ObjectInputStream 对象名 = new ObjectInputStream(new FileInputStream(文件路径));
    //与创建基本流一致,只不过是写成一行代码
    

• transient

  • 在创建变量的时候用transient修饰变量可以防止反序列化被解析

多线程

• 线程就是独立的执行路径
• 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程
• main()称为主线程,为系统的入口,用于执行整个程序
• 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的.
• 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制
• 线程会带来额外的开销,如CPU调度时间,并发控制开销
• 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

创建

thread

• //1.创建一个类继承thread类
  //2.重写run方法
  //3.main方法中创建对象,调用start方法启动线程
  

Runnable

• //1.创建一个类实现runnable接口
  //2.重写run方法
  //3.main方法创建任务对象    --Runable 任务对象名 = new 类名;
  //4.将任务对象交给thread对象处理,调用start方法启动线程   --Thread 对象名 = new Thread(任务对象名);
  

• Runnable匿名内部类写法

  • //1.创建任务对象,直接new runnable重写run方法  --Runnable 任务对象名 = new Runnable(){重写run方法}
    //2.将任务对象交给thread对象处理,调用start方法启动线程 --Thread 对象名 = new Thread(任务对象名);
    

  • //简化
    new Thread(new Runnable(){
        重写run方法
            )).start;
    

Callable

• //1.定义一个类实现callable接口,重写call方法
  //2.main方法中创建任务对象  --Callable<泛型> 任务对象名 = new 类名();
  //3.将任务对象交给FutureTask对象  --FureaTask<泛型> 对象名 = new FutureTask<>(任务对象名);
  //4.将FutureTask对象名交给Thread对象  --Thread 对象名 = new Thread(FutureTask对象名)
  //5.调用start方法
  //6.获取结果,futureTask对象调用get方法
  

API

• //获取当前执行的线程名称
  currenThread对象名.getName();
  //给线程设置名称
  Thread对象名.setName();
  //(子线程使用,主线程不能用)在实现类提供无参有参构造器
  可以在Thread对象直接设置名称,省略setname方法
  

线程状态

• 创建
• 就绪
• 阻塞
• 运行
• 死亡

//更改优先级
setPriority(int newPriprity)
//在指定的毫米数内让当前正在执行的线程休眠
static void sleep(long millis)
//等待该线程终止
void join()
//暂停当前执行的线程对象,并执行其他线程
static void yield()
//中断线程(不建议)
void interrupt()
//测试线程是否处于活动状态
bollean isAlive()

线程休眠

• Thread.sleep();
  

• sleep指定当前线程阻塞的毫秒数

• sleep存在异常interruptedException

• sleep时间达到后线程进入就绪状态

• sleep可以模拟网络延迟,倒计时等

• 每一个对象都有一个锁,sleep不会释放锁

线程礼让

• Thread.yield();
  

• 礼让线程,让当前正在执行的线程暂时,但不阻塞

• 将线程从运行状态转为就绪状态

• 让CPU重新调度,礼让不一定成功

合并线程

• 强制执行该线程,再执行其他线程,其他线程阻塞

线程优先级

• 线程对象名.setpPiority(线程等级);//1最小   10最大
  

同步

• 同步代码块
  • synchronized(实例方法推荐用this,静态方法推荐用类名.class)
• 同步方法
  • 用synchronized修饰方法

并发

同一个对象被多个线程同时操作

锁

• //创建
  Lock 对象名 = new ReentrantLock(); 
  
  //上锁
  对象名.lock();上锁:对象名.lock();
  
  //解锁
  对象名.unlock();
  

线程池

• //创建
  ExecutorService 线程池对象名 = new ThreadPoolExecutor();
  

  • 参数1:指定线程池的线程数量(核心线程)(大于0))--coorPoolSize
  • 参数2:指定线程池可支持的最大线程数量(最大线程数量大于等于核心线程--maximumPoolSize
  • 参数3:指定临时线程的最大存活时间(大于0)--KeepAliveTime
  • 参数4:指定存活时间的单位(秒,分,时,天)--unit
  • 参数5:指定任务队列(不能为null)--workQueue
  • 参数6:指定用哪个线程工厂创建线程(不能为null)--threadFactory
  • 参数7:指定线程忙,任务满的时候,新任务来了怎么办(不能为null)--handler

• //创建
  //不建议用于大型场景
  ExecutorService 线程池对象名 = Executors.newFixedThreadPool(线程数量);
  

• 执行runnable任务

  • //1.创建runnable任务对象
    //2.执行命令
    线程池对象名.execute(任务对象名); --runnable任务对象
    //3.关闭线程池
    线程池对象名.shutdownNow(立即关闭线程池,即使线程池有任务);
    
    //3.关闭线程池
    线程池对象名.shutdown(关闭线程池,等线程池任务执行完后);
    

• 执行callable任务

  • //1.创建callable任务对象
    //2.未来任务
    Fture<泛型> 对象名 = 线程池对象名.submit(任务对象名);
    //3.对象名.get();获取结果
    

定时器

• //创建
  Timer 对象名 = new Timer();
  //创建完成后多久执行,之后每隔多久执行一次);(毫秒值)
  对象名.schedule(new timertask(){
      重写run方法
  }
  

• //创建
  ScheduledExecutorService 对象名 = Executors.newScheduledThreadPool(线程数量);
  //创建完成后多久执行,之后每隔多久执行一次,TimeUnit.单位(秒,分,时,天));
  对象名.scheduleAtFixedRate(new TimerTask() {
      重写run方法
  }
  

• 第一个单线程,不安全,某一个方法挂了其他方法不能执行

• 第二个多线程,安全,推荐使用

通信

ip命令

• ipconfig
  • 查看本机ip地址
• ping ip地址
  • 查看网络是否连通
• ping 本机ip(127.0.0.1)或者localhost
  • 查看本机信息

网络编程

ip

• //创建(本机)
  inetaddress 对象名 = inetaddress.getlocalhost();
  //创建(其他)
  inetaddress 对象名 = inetaddress.getbyname(域名);
  //获取计算机名字
  对象名.gethostname();
  //获取计算机ip地址
  对象名.gethostaddress();
  //判断是否连通
  对象名.isReachable(多长时间内连接);  //返回结果为布尔类型
  

UDP

发送端

• //1.发送端对象创建
  DatagramSocket 发送端对象名 = new DatagramSocket;
  

• //2.数据包(存储数据)
  DatagramPacket 数据包对象名 = new DatagramPacket();
  //参数1:数据.getbytes()
  //参数2:数据长度
  //参数3:服务端的ip地址
  //参数4:定义端口
  //ip地址填255.255.255.255为广播
  //ip地址填:244.0.1.1(244固定,后面几个不固定)为组播
  

• //3.发送数据
  发送端对象名.send(数据包对象名);
  

服务端

• //1.服务端对象创建
  DatagramSocket 服务端对象名 = new DatagramSocket(端口);
  

  • //组播服务端创建
    MulticastSocket 组播服务端对象名 = new MulticastSocket(端口);
    //绑定组播地址
    组播服务端对象名.joinGroup(new inetsocketaddress(组播地址,端口,\),networkinterface.getbyinetaddress(ip地址));
    

• //2.数据包(存储数据)
  DatagramPacket 数据包对象名 = new DatagramPacket();
  //参数1:数据.getbytes()
  //参数2:数据长度
  

• //3.接收数据
  接收端对象名.receive(数据包对象名);
  

TCP

发送(客户)端

• //1.发送端对象创建
  Socket 发送端对象名 = new Socket(参数1:服务器的ip地址,参数2:端口);
  //2.创建输出流
  OutputStream 输出流对象名 = 发送端对象名.getOutputStream();
  //3.将基本流转为打印流
  PrintStream 打印流对象名 = new PrintStream(基本流对象名);
  //4.发送数据
  打印流对象名.print("发送的数据");
  

接收(服务)端

• //1.服务端对象创建
  ServerSocket 服务端对象名= new ServerSocket(发送端端口);
  //2.建立管道调用accept方法接收数据
  Socket 管道对象名 = 服务端对象名.accept();
  //3.创建基本流
  InputStream 输入流对象名 = 管道对象名.getInputStream();
  //4.将基本流转为转换流再缓冲流
  BufferedReader 缓冲流对象名 = new BufferedReader(new InputStreamReader(基本流对象名));
  //5.接收数据
  缓冲流对象名.readline();
  

反射

获取类对象

• //forname方法
  Class 类对象名 = Class.forname(包名.类名);
  //类名.class
  Class 类对象名 = 类名.Class;
  //获取class对象
  对象名.getclass();
  //创建类对象
  Class 类对象名 = 对象名.getclass();
  

获取构造器对象

• //创建类对象
  Class 类对象名 = 对象名.getclass();
  //获取public修饰的构造器
  创建:Constructor 对象名[] = 类对象名.getConstructors();
  //获取全部构造器
  创建:Constructor 对象名[] = 类对象名.getDeclaredConstructors();
  

• 获取某一个构造器(只能public修饰的)

  • //创建(无参)
    Constructor 对象名 = 类对象名.getConstructor();
    //创建(有参)
    Constructor 对象名 = 类对象名.getConstructor(参数1类型.class,参数2类型.class);
    

• 获取某一个构造器(无视私有修饰)

  • //创建(无参)
    Constructor 对象名 = 类对象名.getDeclaredConstructor();
    //创建(有参)
    Constructor 对象名 = 类对象名.getDeclaredConstructor(有参构造器参数1类型.class,有参构造器参数2类型.class);
    

• 获取构造器返回值

  • //返回值为对象类型(无参)
    构造器对象名.newinstance();
    //返回值为对象类型(有参)
    构造器对象名.newinstance(赋值);
    

• 获取成员变量对象

  • //获取全部成员变量
    创建:Field 成员变量对象名[] = 类对象名.getDeclaredFields();
    

  • //获取某个成员变量
    

    • //创建
      Field 成员变量对象名 = 类对象名.getDeclaredField(要获取的成员变量名字);
      //赋值
      成员变量对象名.set(对象名,要赋的值);  //需要暴力反射打开权限
      //取值
      成员变量对象名.get(对象名);  //返回值为获取成员变量的类型
      

• 获取成员方法对象

  • //获取全部成员方法
    创建:Method 成员方法对象名[] = 类对象名.getDeclaredMethods();
    

  • 获取某个成员方法

    • //创建
      Method 成员方法对象名 = 类对象名.getDeclaredMethod(要获取的成员方法名字);
      //参数2如果是无返回类型的为空
      //参数2,3,4.....如果是有返回类型的为:返回值类型.class
      
      //触发方法执行
      成员方法对象名.invoke(对象名);
      //返回值类型为获取成员变量的类型
      //需要暴力反射打开权限
      

暴力反射

• //将权限打开(仅这一次)
  构造器(成员变量)对象名.setaccessible(true);