05.java中常用的类

1.包装类

基本类型	包装类
boolean	Boolean
char	Character
byte	Byte
int	Integer
long	Long
float	Float
double	Double
short	Short

从byte开始的包装类都是继承的Number，然后Number继承的object

从byte上面的都是直接继承的oblect

(1).装箱和拆箱

装箱：基本类型-->包装类型（valueof）

拆箱：包装类型-->基本类型(intvalue)

public class wrapper {
    
    //手动装箱int-->Integer
     int n1=10;
    Integer integer1=Integer.valueOf(n1);
  

    //手动拆箱Inreger-->int
    Integer intege2=new Integer(20);
    int n2=integer.intValue();

    //现在都是自动的装箱拆箱
    //自动装箱
    int n3=100;
    Integer integer3=n3;//调用了valueOf方法
    //自动拆箱
    int n4=integer3;//调用了intvalue方法

}

(2). 包装类(Integer)-->String,String-->包装类(Integer)

包装类-->String

Integer i=10;//自动装箱
//方式1：
String s1=i+"";
//方式2：
String s2=i.toString();
//Integer里的tostring方法返回值String类型
//方式3：
String s3=String.valueOf(i);
//如果不理解可以ctrl+鼠标点击查看源码，valof方法调用了tostring方法，返回值都是String类型的

String-->包装类

String s4="123";
Integer i2=Integer.parseInt(s4);//自动装箱
Integer i3=new Integer(s4);//Integer有一个这样的构造器

(3).常用方法

2.String

1.基本介绍

(1).String对象用于保存字符串，使用双引号括起来

String s1="abc";
String s2="3211";

(2).字符串的字符使用unicode编码，一个字符(不区分字母汉字)占2个字节。1字节=8bit

(3).String类常用的构造器

//String s3=new String();
//String s4=new String(String original);
//String s5=new String(char[] a);
//String s6=new String(char[] a,int startindex,int count);

(4).String 类实现了接口 Serializable[string 可以串行化:可以在网络传输]
接口 Comparable [string 对象可以比较大小]
(5).String 是final类，不能被其他的类继承

(6).String 有属性 private final char value[ ];用于存放字符串内容
一定要注意: value 是一个final类型，不可以修改(内容可以修改，内存地址不能修改)

final char value[]={'a','b','c'};
value[0]='1';//可以修改值
final char v2[]={'1','2','3'};
v2=value;//不能修改地址

2.创建剖析

两种创建String对象的区别：

方式一：直接赋值String s1="qwq''

方式二：调用构造器String s2=new String(''qwq'');

方式一: 先从常量池查看是否有“qwq”数据空间，如果有，直接指向;如果没有则重新创建，然后指向。s1最终指向的是常量池的空间地址。
方式二:先在堆中创建空间，里面维护了value属性，指向常量池的qwq空间,如果常量池没有”qwq”，重新创建，如果有，直接通过value指向。s2最终指向的是堆中的空间地址。

3.string常用方法

equals // 区分大小写，判断内容是否相等
equalslgnoreCase //忽略大小写的判断内容是否相等
length // 获取字符的个数，字符串的长度
indexof //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1
lastIndexof //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
substring //截取指定范围的子串
trim //去前后空格
charAt:获取某索引处的字符,注意不能使用Str[index] 这种方式

public class ff {
    public static void main(String[] args) {
        //1.str1.equals(str2)
        //2.
        String s1="He";
        String s2="he";
        System.out.println(s1.equalsIgnoreCase(s2));//true
        //3.
        System.out.println("qwq".length());//3
        //4.indexof('x')x第一次出现的位置,从0开始，找不到返回-1
        //indexof("xq")还可以是字符串
        String s3="xqwqxw";
        System.out.println(s3.indexOf('x'));//0
        System.out.println(s3.indexOf("xq"));
        //5.lastIndex('w')
        //lastindexof("xw")
        System.out.println(s3.lastIndexOf('w'));//5
        System.out.println(s3.lastIndexOf("xw"));//4
        //6.subString(4)从4开始截取后面的，包括4【】
        //subString(0,5)截取0-5,不包括5【)
        //substring(2,5)[)
        System.out.println(s3.substring(4));//xw
        System.out.println(s3.substring(0,3));//xqw
        System.out.println(s3.substring(2,5));//wqx


    }
}

public class ff2 {
    public static void main(String[] args) {
        String s="hello";
        //1.toUpperCase()输出大写
        System.out.println(s.toUpperCase());
        //2.toLowerCase()输出小写
        String s2="ASD";
        System.out.println(s.toLowerCase());
        //3.concat拼接字符串
        String s3="qwq";
        System.out.println(s.concat(s2).concat(s3));
        //4.replace("a","b")a替换为b
        String s4="汪汪喵喵咩咩";
        System.out.println(s4.replace("汪汪","喵喵"));
        //原来的s4不受影响
        System.out.println(s4);//还是 汪汪喵喵咩咩
        //5.split("x")以x为标准进行分割，返回一个数组，特殊字符要加转义符\
        //\\\\等于\\,一个\配一个\
        String s5="1,2,3,4455";
        String ss1[]=s5.split(",");
        for (int i = 0; i < ss1.length; i++) {
            System.out.println(ss1[i]);
        }
        String s6="C:\\a\\b";
        String ss2[]=s6.split("\\\\");//用\\分割
        for (int i = 0; i < ss1.length; i++) {
            System.out.println(ss1[i]);
        }
        //6.toCharArrY()把字符串转为字符数组
        char cc1[]=s6.toCharArray();
        for (int i = 0; i < cc1.length; i++) {
            System.out.println(cc1[i]);
        }
        //7.compareTo()字符串比较
        //每个字母一一比较，返回前面减后面的askm值
        String s7="asd";
        String s8="aaf";
        System.out.println(s7.compareTo(s8));//s-a的ascm=18
        String s9="asdf";
        String s10="aafff";
        System.out.println(s9.compareTo(s10));//18=s-a
        //
    }

format占位符

3.StringBuffer

1.基本介绍

(1).StringBuffer是final类，不能被继承

(2).他实现了Serializable接口，可以保存到文件，或网络传输

(3).继承了抽象类AbstractStringBuilder

(4).AbstractStringBuilder有属性char[ ]value,存放字符序列，保存在堆中

(5).有缓冲机制，增加或删除不用每次都改堆中的地址，除非放不下了，会开辟更大的地址空间，效率比string高。

2.构造方法

public class a {
    public static void main(String[] args) {
        //常用的构造方法
        //1.创建一个大小为16的char[],用来存放字符内容
        StringBuffer stringBuffer = new StringBuffer();
        //2.创建一个指定大小的char[],100
        StringBuffer stringBuffer1 = new StringBuffer(100);
        //3.创建一个大小为"123''+16的char[]
        StringBuffer stringBuffer2 = new StringBuffer("123");
    }
    
}

3.String和StringBuffer转换

String-->StringBuffer

StringBuffer-->String

public class b {
    public static void main(String[] args) {
        //S--->SB
        //1.使用StringBuffeer构造器
        String s1="qwq hi";
        StringBuffer sb1 = new StringBuffer(s1);
        //2.使用append方法
        StringBuffer sb2 = new StringBuffer();
        sb2=sb2.append(s1);
        //SB-->S
        //1.使用string构造器
        StringBuffer sb3 = new StringBuffer("你好");
        String s3 = new String(sb3);
        //2.使用tostring()
        String s4 = new String();
        s4=sb3.toString();
    }
}

4.常用方法

append添加

delete删除

replace修改(替换)

indexof（查找第一次出现的位置）

insert(在指定位置插入，原来的内容后移)

public class c {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer("qwq");
        //增
        sb1.append(",1");
        sb1.append("2");
        sb1.append("34567");
        System.out.println(sb1);//qwq,123456
        //删:删除索引[3,4)
        System.out.println(sb1.delete(3,4));//qwq123456
        //改(替换):[3,4)
        System.out.println(sb1.replace(3,4,"aa"));//qwqaa23456
        //查：查找字符串第一次出现的位置
        System.out.println(sb1.indexOf("a"));//3
        //插：在3的位置插入a
        System.out.println(sb1.insert(3,"b"));//qwqbaa23456
    }
}

4.StringBuilder

1.基本介绍

(1).一般用在单线程，是stringBuffer的简易替换

(2).继承了abstractStringBulider类，实现了Serializable接口，可以保存到文件，或网络传输

(3).StringBuilder是final类，不能被继承

(4).有属性char[ ]value,存放字符序列，保存在堆中

2.方法

append

insert

和stringBuffer一样

5.String，sBuffer，Sbuilder三者的比较

String: 不可变字符序列，效率低,但是复用率高
StringBuffer: 可变字符序列、效率较高(增删)、线程安全
StringBuilder: 可变字符序列、效率最高、单个线程使用，线程不安全

对字符串做大量修改，不要使用String

结论:
1.如果字符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder
2.如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
3.如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer
4.如果我们字符串很少修改，被多个对象引用，使用String,比如配置信息等
StringBuilder 的方法使用和 StringBuffer 一样

6.Math

public class mathMethod {
    public static void main(String[] args) {
        //1.绝对值abs
        System.out.println(Math.abs(-10));//10
        //2.幂pow
        System.out.println(Math.pow(2,3));//8.0
        //3.向上取整ceil
        System.out.println(Math.ceil(10.34));//11.0
        //4.向下取整floor
        System.out.println(Math.floor(-3.11));//-3.0
        //5.四舍五入round
        System.out.println(Math.round(-88.1));//-88
        System.out.println(Math.round(-88.9));//-89
        //6.开根号sqrt
        System.out.println(Math.sqrt(16));//4.0
        System.out.println(Math.sqrt(-16));//NaN
        //7.[0,1)的随机数random
        //生成[2,7]的随机整数
        System.out.println((int)(2+Math.random()*(7-2+1)));
        //8.max,min
        System.out.println(Math.max(1,2));//2
        System.out.println(Math.min(22,0));//0
    }
}

7.Arrays类

常用方法


public class a {
    public static void main(String[] args) {
        Integer integer[]= {1,2,3,4,5};
        //1.tostring方法显示数组
        System.out.println(Arrays.toString(integer));
        //2.sort排序
        Integer arr[]= {11,2,3,44,-5};
        //默认排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//从小到大
        //定制排序
        //有2个参数,1个要排序的数组，1个匿名内部类,实现compare方法
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1=(Integer) o1;
                Integer i2=(Integer) o2;
                return i2-i1;
                //返回的大于0从大到小，小于0是从小到大
            }
        });
    }
}

public class b {
    public static void main(String[] args) {
        //1.二叉查找,数组要有序的
        int[]arr={1,2,90,123,567};
        int index=Arrays.binarySearch(arr,1);//寻找'1',返回索引值0
        //如果不存在,返回-(low+1)  low是如果存在它应该在的位置的索引
        System.out.println(index);

        //2.copyOf 数组元素的复制
        //从arr数组中复制arr.length个元素到newArr数组中
        int []newArr=Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(newArr));

        //3.fill数组元素的填充
        Integer []num={1,2,3,4};
        Arrays.fill(num,9);
        System.out.println(Arrays.toString(num));

        //4.equals比较2个数组中的元素是否一样
        //num数组被替换为9了都
        Integer []num1={9,9,9,9};
        System.out.println(Arrays.equals(num1,num));

        //5.asList把(2,3,4.5)数据转为一个list集合
        List asList=Arrays.asList(2,3,4,5);
        System.out.println(asList);//{2，3，4，5}
        //返回的asList编译类型List(接口)
        //运行类型java.util.Arrays#ArrayList,Arrays类的静态内部类
    }
}

8.BigInteger和BigDecimal

（1).BigInteger

//当我们编程中，需要处理很大的整数，Long 不够用
//可以使用BigInteger的类来搞定

public class a {
    public static void main(String[] args) {
        BigInteger bigInteger = new BigInteger("2333333333");
        BigInteger bigInteger1 = new BigInteger("2333");
        System.out.println(bigInteger);
        //1，在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + -
        //2.add加法
        BigInteger add = bigInteger.add(bigInteger1);
        System.out.println(add);
        //3.subtract-(减法)   multipy*(乘法)  divide/(除)和上面一样

    }
}

(2).BigDecimal

Decimal小数

//当我们需要保存一个精度很高的小数时，double 不够用
//可以是 BigDecimal

public class a {
    public static void main(String[] args) {
        double d=1.222222222222222222222222222333333333333d;
        System.out.println(d);//精度被缩减
        //当我们需要保存精度很高的数时，使用BigDecimal
        BigDecimal b1=new BigDecimal("1.222222222222222222222222222333333333333");
        BigDecimal b2=new BigDecimal("1.1");
        System.out.println(b1);
        //如果对BigDecimal进行加减乘除，要使用对应方法
        System.out.println(b1.add(b2));
        System.out.println(b1.subtract(b2));
        System.out.println(b1.multiply(b2));
        System.out.println(b1.divide(b2,BigDecimal.ROUND_CEILING));//可能抛出异常ArithmeticException,无限循环小数
        //在调用divide方法时，指定精度即可BigDecimal.ROUND_CEILING
        //保留分子的精度，分子是12位，结果保留12位
        
    }
}

9.日期类

(1).Data(第一代)

package com.qhx.date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SimpleTimeZone;

/**
 * @author qhx
 * @version 1.0
 */
public class datae01 {
    public static void main(String[] args) throws ParseException {
        //这里的Data是util包里的
        Date d1=new Date();//获取当前系统时间
        System.out.println("当前日期="+d1);
        //输出当前日期=Fri Jul 26 10:40:58 CST 2024
        //默认输出日期是国外的,因此通常需要对格式进行转换

        //格式转换
        //把Date格式化
        //创建SimpleDateFormat对象，可以指定相应的格式
        //这里的格式使用的是指定字母
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        String format=sdf.format(d1);
        System.out.println("当前日期"+format);
        //当前日期2024年07月26日 03:50:12 星期五

        //把一个格式化的String 转为对应的Date
        String s="2024年02月10日 10:22:20 星期一";//要和上面sdf的格式一致
        Date p=sdf.parse(s);
        System.out.println("当前日期"+p);//Date格式
        System.out.println(sdf.format(p));//字符串格式

        //(2).
        //通过指定毫秒数得到时间
        Date d2=new Date(9234567);
        System.out.println("d2毫秒数对应的时间"+d2);
        //获取时间对应的毫秒数
        System.out.println("d1对应的毫秒数"+d1.getTime());
    }
}

(2).Calendar(第二代)

package com.qhx.date;

import java.util.Calendar;

public class calendar01 {
    public static void main(String[] args) {
        //1.Calendar是一个抽象类， 并且构造器是private
        //2.可以通过 getInstance() 来获取实例
        //3.提供大量的方法和字段提供给程序员
        Calendar c = Calendar.getInstance(); //创建日历类对象//比较简单，自由
        System .out.println(c);
        //获取日历对象的某个日历字段
        //通过get方法获取
        System.out.println("年："+ c.get(Calendar.YEAR));
        System.out.println("月："+ c.get(Calendar.MONTH));
        System.out.println("日："+ c.get(Calendar.DAY_OF_MONTH));
        System.out.println("时："+ c.get(Calendar.HOUR));
        System.out.println("分："+ c.get(Calendar.MINUTE));
        System.out.println("秒："+ c.get(Calendar.SECOND));
        //根据需求组合
        System.out.println(c.get(Calendar.YEAR)+"年"+c.get(Calendar.MONTH)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");
    }
}

(3).localDate(日期+时间),localTime(时间),localDateTime(日期)(第三代)

package com.qhx.date;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class LocalDate01 {
    public static void main(String[] args) {
        //使用now()返回当前日期时间
        LocalDateTime ldt=LocalDateTime.now();//localTime.now()//localDateTime()
        System.out.println(ldt);
        System.out.println("年=" + ldt.getYear());
        System.out.println("月="+ ldt.getMonth());//英文
        System.out.println("月=" + ldt.getMonthValue());//数字
        System.out.println("日=" + ldt.getDayOfMonth());
        System.out.println("时=" + ldt.getHour());
        System.out.println("分=" + ldt.getMinute());
        System.out.println("秒=" + ldt.getSecond());

        //格式化日期DateTimeFormatter类
        DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy-MM-ddd HH:mm:ss");
        String format=dateTimeFormatter.format(ldt);
        System.out.println("格式化的日期类"+format);


        //通过plus和minus方法对当前日期加或减
        LocalDateTime localDateTime=ldt.plusDays(80);
        //ldt加80天后是多会
        System.out.println("80天后"+dateTimeFormatter.format(localDateTime));

        //ldt122分钟前是多会
        LocalDateTime localDateTime1=ldt.minusMinutes(122);
        System.out.println(dateTimeFormatter.format(localDateTime1));
    }
}

(4).instant时间戳

public class instans01 {
    public static void main(String[] args) {
        //1.通过 静态方法 now() 获取表示当前时间戳的对象
        Instant now = Instant.now() ;
        System.out.println(now);
        //2。通过 from 可以把 Instant转成 Date
        Date date = Date.from(now);
        //3。通过 date的toInstant() 可以把 date 转成Instal
        Instant instant = date .toInstant() ;

    }
}

7.练习

(1).

//下面的代码是否正确,为什么?
//Double d = 100d;
//Float f = 1.5f;

//正确，自动装箱

(2).

//如下两个题目输出结果相同吗?各是什么?
//题目1：
//Object obj1 = true? new Integer(1) : new Double(2.0):
//System.outprintln(obj1);

//题目2:
//Object obj2;
//if(true)
//   obj2 = new Integer(1);
//else
//   obj2 = new Double(2.0):
//System.out.println(obj2);
//输出什么?

//不相同，题目一是三元运算符，第二个表达式是double类型的，会整体的精度提升到double
//三目运算符注意整体性
//题目1输出：1.0
//题目2输出：1

布尔表达式?表达式1:表达式2

运算过程：如果布尔表达式的值为 true ，则返回表达式1 的值，否则返回表达式2 的值

注意三元运算符的整体性。

(3).

Integer创建机制

看看下面代码，输出什么结果？为什么

public void method10() {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);

        //Flase,引用类型==是判断地址是否相同

        Integer m = 1; //底层 Integer.valueOf(1); -> 阅读源码ctrl+鼠标点击
        Integer n = 1;//底层 Integer.valueOf(1);
        System.out.println(m == n);
        //true，没有超出范围
        //所以，Integer.valueOf(1)这里主要是看范围
        // -128 ~ 127 这个范围就直接返回数值
        //超过范围就直接new Integer(xx)
        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);
        //flase,超出范围
    }

(4).

看看下面代码，输出什么结果？为什么

public class f {
    public static void main(String[] args) {
        //示例一
        Integer i1=new Integer( 127 );
        Integer i2=new Integer( 127 );
        System.out.println(i1==i2);
        //示例二
        Integer i3=new Integer( 128 );
        Integer i4=new Integer( 128 );
        System.out.println(i3==i4);
        //示例三
        Integer i5=127;
        Integer i6=127;
        System.out.println(i5==i6);
        //示例四
        Integer i7=128;
        Integer i8=128;
        System.out.println(i7==i8);
        //示例五
        Integer i9=127;
        Integer i10=new Integer(127);
        System.out.println(i9==i10);
        //示例六
        Integer i11=127;
        int i12=127;
        System.out.println(i11==i12);
        //示例七
        Integer i13=128;
        int i14=128;
        System.out.println(i13==i14);
    }

FFTFFTT

(5).

String练习，输出是否正确

public class b {
    public static void main(String[] args) {
        String a = "qwq";
        String b =new String("qwq");
        System.out.println(a.equals(b));//t
        System.out.println(a==b);//f
        System.out.println(a==b.intern());//t
        //b.intern()方法，如果常量池中存在该字符串，返回该字符串在常量池中的地址
        //             如果不存在，则把该字符串添加到常量池中，再返回它的地址
        System.out.println(b==b.intern());//f

    }
}

(6).

String练习，输出是否正确

public class c {
    public static void main(String[] args) {
        String s1 = "qwq";
        String s2 = "java";
        String s4 = "java";
        String s3 = new String("java");
        System.out.println(s2 == s3);//f
        System.out.println(s2 == s4);//t
        System.out.println(s2.equals(s3)); //t
        System.out.println(s1 == s2);//f
    }
}

(7).

输出是否正确

public class e {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "qwq";
        Person p2 = new Person();
        p2.name = "qwq";
        System.out.println(p1.name.equals(p2.name));//T内容相等
        System.out.println(p1.name == p2.name);//T都指向常量池里的qwq
        System.out.println(p1.name =="qwq");//T qwq本来就是池里的，p1.name也指向池里的
        String s1 = new String("bcde");
        String s2 = new String("bcde");
        System.out.println(s1==s2);//F
    }
}
class Person{
    public String name;
}

(8).

以下语句创建了几个对象？画出内存图

String s1 = "hello";
s1="haha";

2个，都是字符串常量对象

String a = "hello"+"abc";

1个，helloabc

String a ="hello"; //创建a对象
String b ="abc";//创建b对象
String c=a+b;//打断点，查看执行过程,进去，跳出，再进去，再跳出
String d="helloabc";
//c!=d

断点查看上面的执行过程

(9).

下面代码输出什么，并说明原因

public class g {
    public static void main(String[] args) {
        String s1 = "qwq";//指向池中的qwq
        String s2 = "java";//指向池中的java
        String s5 = "qwqjava";//指向池中的qwqjava
        String s6 = (s1 + s2).intern();指向池中的qwqjava
        System.out.println(s5 == s6);//t
        System.out.println(s5.equals(s6));//t
    }
}

(10).

下面代码输出什么，并说明原因

public class h {
    String str = new String("qwq");
    final char[] ch = {'j', 'a', 'v', 'a'};
    public void change(String str, char ch[]) {
        str = "java";
        ch[0] = 'h';
    }
    public static void main(String[] args) {
        h ex = new h();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str + "and");//qwqand
        System.out.println(ex.ch);//hava
    }
}

内存分布可以看下面这个链接：

http://t.csdnimg.cn/SinUe

ex.change(ex.str, ex.ch);解读

首先String str=ex.str;把ex的str属性赋给了change方法的str，把ex的ch属性赋给了change方法的ch。

然后，change方法中又把java赋给了str(change方法中的)。

所以，change方法中的str原先指向value，后来指向了常量池的java。

(11).

输出什么

public class lx {
    public static void main(String[] args) {
        String s=null;
        StringBuffer sb = new StringBuffer();
        sb.append(s);
        System.out.println(sb.length());//4
        System.out.println(sb);//null

        StringBuffer sb2 = new StringBuffer(sb);
        System.out.println(sb2);//null
        StringBuffer sb3 = new StringBuffer(s);//报错空指针异常
        System.out.println(sb2);
    }
}

把空字符串追加进去不会报错

(12).

把12345.12变成12,345.12

public class lx2 {
    public static void main(String[] args) {
        String s1="1234567.12";
        StringBuffer sb1 = new StringBuffer(s1);
        for (int i = sb1.lastIndexOf(".")-3; i >0 ; i-=3) {
            sb1=sb1.insert(i,",");
        }
        System.out.println(sb1);

    }
}

(13).

自定义Book类，里面包含name和price。有一个 Book[ ]books = 4书对象。使用前面学习过的传递实现Comparator接口匿名内部类，也称为定制排序。给书排序，可以按照 price (1)从大到小(2)从小到大(3) 按照书名长度从大到小。

public class c {
    public static void main(String[] args) {
        Book[] books = new Book[4];
        books[0]=new Book("红楼梦",100);
        books[1]=new Book("金瓶梅",90);
        books[2]=new Book("青年文献",5);
        books[3]=new Book("从入门到放弃",300);
        //1.price从小到大
        Arrays.sort(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Book book1=(Book) o1;
                Book book2=(Book) o2;
                double priceValue= book2.getPrice()-book1.getPrice();
                //double类型的,不符合返回值要求,转变成下面的
                if(priceValue>0){
                    return 1;//改为-1
                } else if (priceValue<0) {
                    return -1;//改为1，变成从小到大
                }else {
                    return 0;
                }
            }
        });

        //2.书名长度
//        Arrays.sort(books, new Comparator() {
//            @Override
//            public int compare(Object o1, Object o2) {
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                return book2.getName().length() - book1.getName().length();
//                //int类型的,符合返回值要求,不用转变
//            }
//        });

        System.out.println(Arrays.toString(books));
    }
}
class Book{
    private String name;
    private double price;
    public Book(String name,int price) {
        this.name= name;
        this.price = price;
    }

    public Book(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

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

    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

(14).

public class e1 {
    public static void main(String[] args) {
        String str="123456";
        try {
            str=reverse(str,1,1);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        System.out.println(str);
    }
    public static String reverse(String str,int start,int end){
        if(!(str!=null && start>=0 && end>start&&end<str.length())){
            throw new RuntimeException("参数错误");
        }
        char char1[]=str.toCharArray();
        char tepm=' ';
        for (int i = start,j=end; i<j ; i++,j--) {
            tepm=char1[i];
            char1[i]=char1[j];
            char1[j]=tepm;
        }
        return new String(char1);
    }
}

(15).

//1.编写方法userRegister(String name,String pwd,String email)
//2.针对输入内容进行校验
public class e2 {
    public  static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入用户名：");
        String s1=sc.next();
        System.out.println("请输入密码：");
        String s2=sc.next();
        System.out.println("请输入邮箱：");
        String s3=sc.next();
        try {
            userGister(s1,s2,s3);
            System.out.println("注册成功");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    public static  void userGister(String s1,String s2,String s3){

        if(!(s1.length()>=2 && s1.length()<=4) ){
            throw new RuntimeException("错误：用户名长度应为2，3，4位");
        }

        if(!(s2.length()==6 &&  isDigital(s2) )){
            throw new RuntimeException("错误：密码应该是6位数字");
        }

        int i=s3.indexOf('@');
        int j=s3.indexOf('.');
        if(!(i>0 && j>i)){
            throw new RuntimeException("错误：@开始，且有.");
        }
    }
    //判断是否全是数字
    public static boolean isDigital(String s2) {
        char[] chars = s2.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] < '0' || chars[i] > '9') {//askm值比较
                return false;
            }//里面这个循环都没有返回false,则就是正确的
        }
        return true;
    }
}

(16).

public class e4 {
    public static void main(String[] args) {
        String s="aa";
        printName(s);
    }
    public static  void printName(String s){
        if(s==null){
            System.out.println("s 不能为空");
            return;
        }
        String[] name=s.split(" ");//按空格分割，存储到字符串数组中
        if (name.length!=3){
            System.out.println("输入的字符格式不对");
            return;
        }
        String format=String.format("%s,%s,%c",name[2],name[0],name[3].toUpperCase().charAt(0));
        //charAt(0)返回0位置的字符
        System.out.println(format);
    }
}

(17).

统计字符串中有几个大学字母，小写字母，数字

public class e5 {
    public static void main(String[] args) {
        String s="ssAA123";
        count(s);
    }
    public static void count(String s){
        if(s==null){
            System.out.println("0");
        }
        int numCount=0,lowCount=0,supCount=0;
        int m=s.length();
        for (int i = 0; i < m; i++) {
            if (s.charAt(i)>='0' && s.charAt(i)<='9'){
                numCount++;
            }
            if (s.charAt(i)>='a'&& s.charAt(i)<='z'){
                lowCount++;
            }
            if (s.charAt(i)>='A'&& s.charAt(i)<='Z'){
                supCount++;
            }
        }
        System.out.println(numCount);
        System.out.println(lowCount);
        System.out.println(supCount);
    }
}

(18).