AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

# Day13-Java基础

2022-01-17 113
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： # Day13-Java基础

Day13-Java

文章目录

1、线程池

线程池就是多个线程封装在一起操作。

1.1 线程池概念

在生活中经常遇见，今天开发一个项目需要20个人一起开发

  • 这个活很大，有多少人要多少人
  • 这个活很大，但是要求10个人
  • 这个活很大，但只要求1个人做

image.png

追加一个并发访问的程序报：java.util.concurrent,对于此线程池的操作的核心类和接口就定义在之中。这里面有两个核心的接口：

  1. 普通的执行线程池定义：Interface ExecutorService
  2. 调度线程池：Interface ScheduledExecutorService

如果要进行线程池的创建一般使用Class Executors这个类

  • 创建无法小限制的线程池：public static ExecutorService newCachedThreadPool()
  • 创建固定大小的线程池：public static ExecutorService newFixedThreadPool(int nThreads)
  • 单线程池：public static ExecutorService newSingleThreadExecutor()
  • 创建定时调度池：public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
1.2 线程池的实现

创建无限大小的线程池

package com.day13.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PoolDemo1 {
  public static void main(String[] args) throws Exception {
    // TODO Auto-generated method stub
    //创建了一个线程池的模型，但是后面没有线程
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 10; i++) {
      int index = i;
      Thread.sleep(200);
      executorService.submit(()-> {
        System.out.println(Thread.currentThread().getName() + ",i = " + index);
      });
    }
    executorService.shutdown();
  }
}

创建固定大小的线程池

package com.day13.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PoolDemo1 {
  public static void main(String[] args) throws Exception {
    // TODO Auto-generated method stub
    //创建了一个线程池的模型，但是后面没有线程
    ExecutorService executorService = Executors.newFixedThreadPool(3);
    for (int i = 0; i < 10; i++) {
      int index = i;
      Thread.sleep(200);
      executorService.submit(()-> {
        System.out.println(Thread.currentThread().getName() + ",i = " + index);
      });
    }
    executorService.shutdown();
  }
}

创建我们的单线程线程池

package com.day13.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PoolDemo1 {
  public static void main(String[] args) throws Exception {
    // TODO Auto-generated method stub
    //创建了一个线程池的模型，但是后面没有线程
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    for (int i = 0; i < 10; i++) {
      int index = i;
      executorService.submit(()-> {
        System.out.println(Thread.currentThread().getName() + ",i = " + index);
      });
    }
    executorService.shutdown();
  }
}

定时调度池

package com.day13.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class PoolDemo1 {
  public static void main(String[] args) throws Exception {
    // TODO Auto-generated method stub
    //创建了一哥具备有三个线程大小的定时调度池
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
    for (int i = 0; i < 10; i++) {
      //Thread.sleep(200);
      int index = i;
      executorService.scheduleAtFixedRate(new Runnable(){
        @Override
        public void run() {
          // TODO Auto-generated method stub
            System.out.println(Thread.currentThread().getName() + ",i = " + index);
        }
      }, 3, 2, TimeUnit.SECONDS);//使用的是一个秒的单位，表示3秒后开始执行，而后每过2秒执行一次
    }
  }
}

线程池给我们开发者带来唯一好处的就是允许多个线程按照组的模式进行程序的处理，这样在一个业务逻辑非常复杂的情况下，性能就会得到很好的提升。

2、StringBuffer类

对于类库的学习，不可能全学完。你所需要知道就是如何面对解决问题的方法。要学会查询文档。

StringBuffer类之前首先来简单回顾一下String类的特点：

String类的对象有两种实例化方式，一种是直接赋值，只会开辟一块堆内存空间，而且对象可以自动入池，另外一种方式使用构造方法完成，会开辟两块空间，有一块空间将称为垃圾，并且不会自动入池，但是可以通过intern()方法手工入池；

字符串常亮一旦声明则不能改变，而字符串对象可以改变，但是改变的是其内存地址的指向；

通过以上的几个特点就可以清楚的发现，String类是表示字符串使用最多的类，但是其不合适于被频繁修改的字符串操作上，所以在这种情况下，往往可以使用StringBuffer类，即：StringBuffer类方便用户进行内容的修改，在String类之中使用“+”作为数据库的连接操作，而在StringBuffer类之中使用append()方法进行数据的连接。

使用StringBuffer操作，StringBuffer内容可以改变。

package com.day13.demo;
public class BufferDemo {
  public static void main(String[] args) {
    StringBuffer buf = new StringBuffer();
    buf.append("hello").append(",world!");
    fun(buf);//修改了buf的内容
    System.out.println(buf);
  }
  public static void fun(StringBuffer tem){
    tem.append("\n").append("zsr");
  }
}

String和StringBuffer最大的区别就是：String的内容无法修改，而StringBuffer的内容可以修改。但是在开发的选择还是优先选择String类。

现在学习的字符串的操作类就有两个了：String，StringBuffer，那么下面通过这两个类的定义来研究一下关系：

String类： StringBuffer类：
public final class String
extends Object
implements Serializable,Comparable,CharSequence		 public final class StringBuffer
extends Object
implements Serializable, CharSequence

可以发现两个类都是“CharSequence”接口的子类。这个接口描述的是字符集，所以串就属于字符集的子类，如果以后看见CharSequence最简单的联想就是字符串。但是有一个小小的问题需要注意一下就是String和StringBuffer两个类型无法直接转换。

利用StringBuffer：利用StringBuffer构造方法、append()方法

将String变为StringBuffer

1.直接利用StringBuffer类的构造方法，public StringBuffer(String str)

package com.day13.demo;
public class BufferTest{
  public static void main(String[] args) throws Exception {
    String str = "Hello World.";
    StringBuffer buf = new StringBuffer(str);
    fun(buf);
    System.out.println(buf);
}
  private static void fun(StringBuffer temp) {
    temp.append("\n").append("zsr");
  }
}

2.利用StringBuffer类的append()方法

package com.day13.demo;
public class BufferTest{
  public static void main(String[] args) throws Exception {
    String str = "Hello World.";
    StringBuffer buf = new StringBuffer();
    buf.append(str);
    fun(buf);
    System.out.println(sb);
  }
  private static void fun(StringBuffer temp) {
    temp.append("\n").append("zsr");
  }
}

将StringBuffer变成String，利用StringBuffer类的toString()方法完成

package com.day13.demo;
public class BufferTest{
  public static void main(String[] args) throws Exception {
    StringBuffer buf = new StringBuffer("hello,World!");
    String str = buf.toString();
    System.out.println(str);
  }
}

实际上StringBuffer还是有一些String类所没有的特点的。

1.字符串反转操作，public StringBuffer reverse()

package com.day13.demo;
public class BufferTest{
  public static void main(String[] args) throws Exception {
    StringBuffer buf = new StringBuffer("hello,World!");
    System.out.println(buf.reverse());
  }
}

2.删除指定范围内的数据，public StringBuffer delete(int start, int end)

package com.day13.demo;
public class BufferDemo {
  public static void main(String[] args) {
    StringBuffer buf = new StringBuffer("Hello,World!");
    System.out.println(buf.delete(5, 11));
    }
}

3.插入数据的方法， public StringBuffer insert(int offset, Object obj)

package com.day13.demo;
public class BufferDemo {
  public static void main(String[] args) {
    StringBuffer buf = new StringBuffer("Hello,World!");
    System.out.println(buf.delete(5,11).insert(0, "你好，"));
  }
}

面试题：请解释String、StringBuffer、StringBuilder的区别?

  • String的内容不可以修改，StringBuffer与StringBuilder内容可以修改
  • StringBuffer采用同步处理属于线程安全操作，StringBuilder采用异步处理属于线程不安全操作。

3、Runtime类

在每一个JVM的进程中，都会存在一个运行时的操作类的对象，而这对象所属的类型就是Runtime类。打开这个类的文档，发现这个类之中并没有构造方法的定义，可是按照之前所学，每个类至少有一个构造方法，而这个类的构造方法实际上存在只是不被外部看见而已，因为构造方法私有化了，这是一个标准的单例设计模式，既然是单例设计模式则在这个类之中一定会存在一个static型方法，可以取得本类的Runtime实例化对象：public  static Runtime getRuntime()。

取得了Runtime类之后最主要的功能就是可以通过它来观察当前的内存操作情况：

方法名称 类型 描述
public long freeMemory() 普通 取得当前空余内存空间大小
public long totalMemory() 普通 取得当前可以使用总空间大小
public long maxMemory() 普通 取得最大的可用内存空间的大小
public native void gc() 普通 执行垃圾收集处理

观察一下内存信息的取得

package com.day13.demo;
public class RuntimeDemo {
  public static void main(String[] args) {
    Runtime run = Runtime.getRuntime();
    System.out.println("1、MAX=" + byteToM(run.maxMemory()));
    System.out.println("1、TOTAL=" +  byteToM(run.totalMemory()));
    System.out.println("1、FREE=" +  byteToM(run.freeMemory()));
  }
  public static double byteToM(long num){
    return (double) num / 1024 / 1024;
  }
}

gc垃圾回收

package com.day13.demo;
public class RuntimeDemo {
  public static void main(String[] args) {
    Runtime run = Runtime.getRuntime();
    System.out.println("1、MAX=" + byteToM(run.maxMemory()));
    System.out.println("1、TOTAL=" +  byteToM(run.totalMemory()));
    System.out.println("1、FREE=" +  byteToM(run.freeMemory()));
    String str = "";
    for (int i = 0; i < 2222; i++) {
      str += i;
    }
    System.out.println("2、MAX=" + byteToM(run.maxMemory()));
    System.out.println("2、TOTAL=" +  byteToM(run.totalMemory()));
    System.out.println("2、FREE=" +  byteToM(run.freeMemory()));
    run.gc();//垃圾收集
    System.out.println("3、MAX=" + byteToM(run.maxMemory()));
    System.out.println("3、TOTAL=" +  byteToM(run.totalMemory()));
    System.out.println("3、FREE=" +  byteToM(run.freeMemory()));
  }
  public static double byteToM(long num){
    return (double) num / 1024 / 1024;
  }
}

面试题：什么叫gc？如何处理

  • gc（Garbage Conllector）：垃圾收集器，用于释放无用的内存空间
  • gc有两种处理形式，一种是自动不定期调用，另外一种是使用Runtime的gc()方法手工处理调用。

4、System类

实际上在之前进行的数组拷贝就是运用System类中的public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

在这个类中提供有一个取得当前日期时间数的方法**public static long currentTimeMillis()；**通过此方法可以取得某一个操作花费的时间。

观察currentTimeMillis()的使用

package com.day13.demo;
public class SystemDemo {
  public static void main(String[] args) {
    long start = System.currentTimeMillis();
    String str = "";
    for (int i = 0; i < 2222; i++) {
      str += i;
    }
    long end = System.currentTimeMillis();
    System.out.println("花费时间：" + (end - start) + "ms");
  }
}

可是在System类之中还存在了一个很有意思的方法：public static void gc()，但是这个gc()方法并不是一个新的gc()方法而是间接调用了一个Runtime类之中的gc()方法，不表示一个重写的方法。

在之前一直强调过一个概念：一个类对象的创建一定要使用构造方法，那么一个对象不使用构造方法了，就一个被释放，被释放的时候一改也有一个方法进行支持才对。所以要想做这种收尾的操作，可以让一个类去覆写object中的finalize()方法。此方法由Object类定义：protected void finalize() throws Throwable。在对象回收之前有可能出现异常或者错误，但是即使出现了也不会影响程序的执行，即：不会因为异常而导致程序的中断执行。

finalize()方法使用

package com.day13.demo;
class Person{
  public Person(){
    System.out.println("问啊娃娃，出来了！");
  }
  @Override
  protected void finalize() throws Throwable {
    // TODO Auto-generated method stub
    System.out.println("我要下地狱了，下辈子不要当人了——");
    throw new Exception("继续要活几千年");
  }
}
public class FinalizeDemo {
  public static void main(String[] args) {
    Person person = new Person();
    person = null;
    System.out.println("已经转世不为人了");
    System.gc();
  }
}

面试题：请解释final、finally、finalize的区别？

  • final是一个关键字，用于定义不能够被继承的父类、不能够覆写的常量
  • finally是异常处理的统一出口
  • finalize是Object类中的方法，用于在对象回收前进行调用

5、对象克隆

克隆就是对象复制的一个概念，不过这种概念一般使用的比较少，因为很少有人去复制已经存在的对象。Object类本身就支持对象克隆方法。可以发现protected  Object clone() throws  CloneNotSupportedException；我们要想实现克隆，那么我们并不是所有类的对象可以随便克隆，需要被克隆的对象所在类一定要实现Cloneable接口，而最关键的是该接口并没有任何的抽象方法，所以该接口只是一个标识接口，表示一种能力。

对象克隆实现

package com.day13.demo;
class Per implements Cloneable{//必须实现此接口
  private String name;
  private int age;
  public Per(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
  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 "Per [name=" + name + ", age=" + age + "]";
  }
  @Override
  //覆写权限扩大  protected 扩大到 public
  public Object clone() throws CloneNotSupportedException {
    // TODO Auto-generated method stub
    return super.clone();//父类负责克隆
  }
}
public class CloneDemo {
  public static void main(String[] args) throws Exception{
     Per perA = new Per("kaco",12);
     //perA.clone();不能在这写的原因是因为此方法是protected权限 只能在不同包的子类中实现此方法
     Per perB = (Per) perA.clone();
     perB.setAge(100);
     System.out.println(perA);
     System.out.println(perB);
  }
}

意义不大，需要清楚表示接口的作用，表示的是一个能力。

6、Date类

日期数据类型一定要重视，所有的开发必定要有日期。

6.1 日期处理类—Date类

java.util.data类是在整个程序处理之中唯一可以取得日期当前日期实例化对象的操作方法，也就是说我们要取出当前日期输出Date类对象即可。

package com.day13.demo;
import java.util.Date;
public class DateDemo1 {
  public static void main(String[] args) {
    Date date = new Date();
        //Tue Aug 17 17:01:50 CST 2021
    System.out.println(date);
  }
}

在Date类中最需要关心的一个核心问题：long可以描述日期，看了一通过Date类中提供的方法来进行观察。

方法名称 类型 描述
public Date(long date) 普通 将long类型变为Date类型数据
public long getTime() 普通 将Date类型变为long类型数据

观察转化

package com.day13.demo;
import java.util.Date;
public class DateDemo1 {
  public static void main(String[] args) {
    long num = System.currentTimeMillis();
    System.out.println(new Date(num));
    System.out.println(new Date(num).getTime());
  }
}

这中简单的转换在以后的程序开发经常会使用。

6.2 日期格式化—SimpleDateFormat类（核心）

虽然Date可以取得当前的日期时间，但是取出的结构不是我们所喜欢的格式，这时候就需要我们进行格式的转化，使用的是java.text包

image.png

但是日期格式里面需要设置一些日期标记：年(YYYY)、月(MM)、日(dd)、时(HH)、分(mm)、秒(ss)、毫秒(SS);

实现日期格式化处理（日期格式化之后是字符串）

package com.day13.demo;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo1 {
  public static void main(String[] args) {
    Date date = new Date();
    String str = "YYYY-MM-dd HH:mm:ss";
    SimpleDateFormat sdf = new SimpleDateFormat(str);
    String dateFromat = sdf.format(date);
    System.out.println(dateFromat);
  }
}

将字符串变为Date类型

package com.day13.demo;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo2 {
  public static void main(String[] args) throws ParseException{
    Date date = new Date();
    System.out.println(date);
    String str = "yyyy-MM-dd HH:mm:ss";
    SimpleDateFormat sdf = new SimpleDateFormat(str);
    //将Date类型转化为字符串类型
    String newdateStirng = sdf.format(date);
    System.out.println(newdateStirng);
    //将字符串转化为Date类型
    Date newdate = sdf.parse(newdateStirng);
    System.out.println(newdate);
  }
}

7、 数字操作类—Math类

在Java.lang.Math类之中定义了所有的于数学有关的基本公式，在这个类之中所有的方法都是static型的方法，强调一个方法：round()，public static long round(double a)，表示四舍五入。

package com.day13.demo;
public class MathDemo {
  public static void main(String[] args) {
    System.out.println(Math.round(13.51));
    System.out.println(Math.round(13.5));
    //如果负数小数，没大于0.5都不进位
    System.out.println(Math.round(-13.51));
    System.out.println(Math.round(-13.5));//-13
  } 
}

希望可以准确的保存小数位进行处理。

需要保留几位小数

package com.day13.demo;
class MyMath{
  public static double round(double num, int scale){
    return Math.round(num * Math.pow(10, scale)) / Math.pow(10, scale);
  }
}
public class MathDemo {
  public static void main(String[] args) {
        //1234.457
    System.out.println(MyMath.round(1234.4567, 3));
  } 
}
7.1 随机数—Random()

Java .util.Random的主要主要作用就是产生随机数，下面通过一个代码来观察就行。

网站开发的随机验证码

package com.day13.demo;
import java.util.Random;
public class RandomDemo {
  public static void main(String[] args) {
    char data [] = new char[]{'a','b','c','d','e'};
    for (int i = 0; i < 4; i++) {
      System.out.print(data[new Random().nextInt(data.length)]);
    }
  }
}
7.2 大数字操作类

如果说现在有两个非常大的数字要进行数学操作，你们认为要怎么做？这个时候数字已经超过了double的范围，那么只能利用字符串来表示，取出每一个字符串变为数字后进行数学计算，这种方式的难度较高，为了解决这种问题，在Java之中提供了两个大数字操作类：java.math包中BigInteger,BigDecimal，而这两个类是属于Number的子类。

1.大整数操作类：BigIntegr

之前已经强调过了，如果数字较大，肯定按照String来处理，所以这一点可以通过Biginteger的构造方法来观察：

构造：public BigInteger(String val)；

而且在BigInteger类之中定义了一些基本的数学计算：

加法：public BigInteger add(BigInteger val)；

减法：public BigInteger subtract(BigInteger val)；

乘法：public BigInteger multiply(BigInteger val)；

除法（不保存余数）：public BigInteger divide(BigInteger val)；

除法（保存余数）：public BigInteger divideAndRemainder(BigInteger val)

大数的四则运算

package com.day13.demo;
import java.math.BigInteger;
public class BigAddDemo {
  public static void main(String[] args) {
    BigInteger bigA = new BigInteger("123712487812974891274891274128947891");
    BigInteger bigB = new BigInteger("43895748395789347589347589398");
    System.out.println("加法计算：" + bigA.add(bigB));
    System.out.println("减法计算：" + bigA.subtract(bigB));
    System.out.println("乘法计算：" + bigA.multiply(bigB));
    System.out.println("除法计算：" + bigA.divide(bigB));
    BigInteger result[] = bigA.divideAndRemainder(bigB);
    System.out.println("除法计算：" + result[0] + "." + result[1]);
  }
}

2.大小数操作类：BigDcimal

BigDecimal类表示的是大小数操作类，但是这个类也具备了于之前同样的基本计算方式，而在实际的工作之中，是用这个类最多的情况是进行准确位数的四舍五入操作，如果要完成这一操作需要关心BigDecimal类中的以下定义：

构造：public BigDecimal(double val)；

除法：public BigDecimal divide(BigDecimal divisor ,int scale ,int roundingMode)；

进位模式：public static final int ROUND_HALF_UP。

四舍五入进位操作

package com.day13.demo;
import java.math.BigDecimal;
//大数进位方法
class MyMath1{
  public static double round(double num, int scale){
    return new BigDecimal(num).divide(new BigDecimal(1), scale, BigDecimal.ROUND_HALF_DOWN).doubleValue();
  }
}
public class BigDecimalDemo {
  public static void main(String[] args) {
    System.out.println(MyMath1.round(2138845.4567, 3));
  }
}

8、Arrays类

排序操作：java.util.Arrays.sort（数组名称），对于Arrays类一直是进行数组排序的操作，类一直进行数组排序的操作，而Arrays类是定义在java.util包下的一个操作类，在这个类之中定义了所有的与数组有关的基本操作：二分查找，拷贝操作，相等判断，填充，变为字符串输出等。

package com.day13.demo;
import java.util.Arrays;
public class ArraysDemo {
  public static void main(String[] args) {
    int dataA[] = new int []{1,2,3,4,5,6};
    int dataB[] = new int []{1,2,3,4,5,6};
    //数组输出
    System.out.println(Arrays.toString(dataA));
    //两个数组进行比较
    System.out.println(Arrays.equals(dataA,dataB));
    //数组二分法查找
    System.out.println(Arrays.binarySearch(dataA, 4)+1);
  }
}

9、比较器—Comparable

9.1 Comparable

对象数组排序：public static void sort(Object[] a)

package com.day13.demo;
import java.util.Arrays;
class Pers{
  private String name;
  private int age;
  public Pers(String name, int age) {
    this.name = name;
    this.age = age;
  }
  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 "Pers [name=" + name + ", age=" + age + "]";
  }
}
public class ComparableDemo {
  public static void main(String[] args) {
    Pers pers[] = new Pers[]{
      new Pers("张三",12),
      new Pers("李四",23),
      new Pers("刘武",54)//对象数组
    };
    Arrays.sort(pers);//要进行对象数组的排序处理
    System.out.println(Arrays.toString(pers));
  }
}

这个时候没有任何的语法错误，即：程序的代码是正确的，但是在程序执行的时候出现了以下的问题：

Exception in thread "main" java.lang.ClassCastException: com.day13.demo.Pers cannot be cast to java.lang.Comparable
  at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)
  at java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
  at java.util.Arrays.sort(Arrays.java:1246)
  at com.day13.demo.ComparableDemo.main(ComparableDemo.java:36)

明确的告诉用户现在发生了“ClassCaseException”，类转换异常，Person类不能变为Comparables实例。

如果要为对象指定比较规则，那么对象所在的类必须实现Comparable接口，下面首先来看一下这个接口的定义：

public interface Comaparable<T>{
  public int compareTo（T o）
}

Stirng类中的compareTo()就属于覆写Comaparable接口所的来的方法。

image.png

实现对象数组的排序

package com.day13.demo;
import java.util.Arrays;
class Pers implements Comparable<Pers>{
  private String name;
  private int age;
  public Pers(String name, int age) {
    this.name = name;
    this.age = age;
  }
  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 "Pers [name=" + name + ", age=" + age + "]\n";
  }
  @Override
  public int compareTo(Pers o) {
    // TODO Auto-generated method stub
    //升序排序 如果降序排序将1 和 -1 进行位置调换
    if(this.age > o.age){
      return -1;
    }else if(this.age < o.age){
      return 1;
    }else{
      return 0;
    }
  }
}
public class ComparableDemo {
  public static void main(String[] args) {
    Pers pers[] = new Pers[]{
      new Pers("张三",12),
      new Pers("李四",23),
      new Pers("刘武",54)//对象数组
    };
    Arrays.sort(pers);//要进行对象数组的排序处理
    System.out.println(Arrays.toString(pers));
  }
}

只要是对象数组排序，就必须有Comparable接口。

9.2 二叉树( Binary Tree )

二叉树是一种排序的基本的数据结构，而如果要想为多个对象进行排序，那么就必须可以区分出对象的大小，那么就必须依靠Comparable接口完成。

二叉树的基本原理：取第一个元素作为根节点，之后每一个元素的排列要求：如果比根节点晓得数据放在左子树，如果比根节点大的数据放在右子树，在输出的时候采用中序（左-根-右）遍历的方式完成。

但是不管是何种方式操作，一定要记住，这种数据结构的实现永远都需要依靠节点类，而这个时候的节点类要保存两个节点：左，右。

10、国际化

在java.util.Locale可以找java提供国际化的相关信息

Locale构造：public Locale(String language, String country)

观察区域和语言代码

package com.day13.demo;
import java.util.Locale;
public class LocalDemo {
  public static void main(String[] args) {
    System.out.println(Locale.CHINA);//zh_CN
    System.out.println(Locale.CHINESE);//zh
  }
}
  • 中国Locale：public static final Locale CHINESE
  • 美国Locale：public static final Locale US
  • 取得当前的Locale对象：public static Locale getDefault()

当我们用eclipse打开Message.properties进行编写后不要慌，我们还有一个非常强大的工具在JDK中，CLASSPATH:C:\Program  Files\Java\jdk1.8.0_241\bin  自己安装JDK的环境目录下有一个叫native2ascii.exe可以帮助我们进行转码。这种做法非常麻烦，如果要开发国际版本的软件还是自己安装一个编辑软件比较好。

image.png

语言配置文件Message.properties

welcome.info = \u5317\u4EAC\u6B22\u8FCE\u4F60\uFF01

测试文件LocaleDemo.java

package com.day13.demo;
import java.util.ResourceBundle;
public class LocaleDemo {
  public static void main(String[] args) {
    //这个时候设置的baseName没有后缀，而且一定要在CLASSPATH之中
    ResourceBundle res = ResourceBundle.getBundle("com.day13.msg.Message");
        //北京欢迎你！
    System.out.println(res.getString("welcome.info"));
  }
}

资源文件的名称就只是 包.名称前缀


文章标签：
Java
Android开发
编解码
安全
数据库
调度
开发者
设计模式
关键词：
Java基础
java厂长
目录
相关文章
编程指南针
|
7月前
|
存储 缓存 Java
最新Java基础系列课程--Day10-IO流文件处理
最新Java基础系列课程--Day10-IO流文件处理
编程指南针
88 2
编程千纸鹤
|
7月前
|
存储 Java
最新Java基础系列课程--Day10-IO流文件处理（一）
最新Java基础系列课程--Day10-IO流文件处理
编程千纸鹤
80 0
java冯坚持
|
2月前
|
存储 缓存 Java
java基础：IO流 理论与代码示例（详解、idea设置统一utf-8编码问题）
这篇文章详细介绍了Java中的IO流，包括字符与字节的概念、编码格式、File类的使用、IO流的分类和原理，以及通过代码示例展示了各种流的应用，如节点流、处理流、缓存流、转换流、对象流和随机访问文件流。同时，还探讨了IDEA中设置项目编码格式的方法，以及如何处理序列化和反序列化问题。
java冯坚持
92 1
java基础：IO流 理论与代码示例（详解、idea设置统一utf-8编码问题）
Shadow_143
|
6月前
|
Java
【Java基础】输入输出流（IO流）
Java基础、输入输出流、IO流、流的概念、输入输出流的类层次结构图、使用 InputStream 和 OutputStream流类、使用 Reader 和 Writer 流类
Shadow_143
219 2
程序员小海绵
|
3月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射（2023版）
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
程序员小海绵
65 3
不会编程的小孩子
|
6月前
|
安全 Java
java基础-hashmap-io
java基础-hashmap-io
不会编程的小孩子
48 3
Shadow_143
|
6月前
|
搜索推荐 算法 Java
【Java基础】 几种简单的算法排序
几种简单的JAVA算法排序
Shadow_143
56 4
hsfxuebao
|
6月前
|
存储 缓存 Java
Java基础17-读懂Java IO流和常见面试题（二）
Java基础17-读懂Java IO流和常见面试题（二）
hsfxuebao
48 0
hsfxuebao
|
6月前
|
存储 Java Unix
Java基础17-读懂Java IO流和常见面试题（一）
Java基础16-读懂Java IO流和常见面试题（一）
hsfxuebao
80 0
技能实验室
|
7月前
|
Java
Java基础教程(12)-Java中的IO流
【4月更文挑战第12天】Java IO涉及输入输出，包括从外部读取数据到内存（如文件、网络）和从内存输出到外部。流是信息传输的抽象，分为字节流和字符流。字节流处理二进制数据，如InputStream和OutputStream，而字符流处理Unicode字符，如Reader和Writer。File对象用于文件和目录操作，Path对象简化了路径处理。ZipInputStream和ZipOutputStream则用于读写zip文件。
技能实验室
69 2

热门文章

最新文章

  • 1
    Java volatile关键字：你真的懂了吗？
  • 2
    java小工具util系列2：字符串工具
  • 3
    Java爬虫：数据采集的强大工具
  • 4
    Java多线程并发编程：同步机制与实践应用
  • 5
    Java中的异常处理：从基础到高级
  • 6
    深入理解Java异常处理机制
  • 7
    Liunx部署java项目Tomcat、Redis、Mysql教程
  • 8
    Java爬虫：深入解析商品详情的利器
  • 9
    java实现从HDFS上下载文件及文件夹的功能，以流形式输出，便于用户自定义保存任何路径下
  • 10
    Java 异常处理：机制、策略与最佳实践
  • 1
    【Bug合集】——Java大小写引起传参失败，获取值为null的解决方案
    23
  • 2
    JavaEE初阶——初识EE（Java诞生背景，CPU详解）
    13
  • 3
    反射-----浅解析（Java）
    14
  • 4
    Java—多线程实现生产消费者
    21
  • 5
    Java使用sql查询mongodb
    24
  • 6
    Java最新图形化界面开发技术——JavaFx教程（含UI控件用法介绍、属性绑定、事件监听、FXML）
    74
  • 7
    Java中的算法优化与复杂度分析
    15
  • 8
    Java的基础概念一
    20
  • 9
    Java基础-常用API-Object类
    29
  • 10
    Java多线程是什么
    23

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)