java基础 day07 常用类

最新推荐文章于 2024-09-13 21:40:38 发布

装着二筒的包

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量51

点赞数

文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/Jtyazs/article/details/132340034

版权

Object类

Object是Java中，类结构的根类，所有的类都是直接或者间接继承Object类

Object类有一个默认的无参构造方法，用来给子类访问

Object类中的方法

需要掌握：

1，boolean equals(Object obj) 指示一些其他对象是否等于此。

2，int hashCode() 返回对象的哈希码值。

3，String toString() 返回对象的字符串表示形式。

需要了解：

4，protected Object clone() 创建并返回此对象的副本。

5，protected void finalize() 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象，对象被回收的时候，可能会调用这个方法

6，Class<?> getClass() 返回此对象的字节码文件对象。

public class Student implements Cloneable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class TestStudent {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student("张三", 20);
        //调用克隆方法
        Object o = s1.clone();
        Student s2 = (Student)o;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 == s2);
    }
}

System类

System类包含几个有用的类字段和方法。它不能被实例化。

System类提供的System包括标准输入，标准输出和错误输出流;

访问外部定义的属性和环境变量; 一种加载文件和库的方法; 以及用于快速复制数组的一部分的实用方法。

常用方法：

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将指定源数组中的数组从指定位置复制到目标数组的指定位置。

         int[] arr = {10,20,30,40,50};
        int[] arr1 = {100,200,300,400,500};
        //当前数组复制指定数组中的内容，替换当前数组指定位置的内容
        System.arraycopy(arr,2,arr1,3,2);

        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));

static long currentTimeMillis() 返回当前时间（以毫秒为单位）。

//当前时间的毫秒值，一般用来在某段代码执行的前后分别返回，用来计算程序的执行时间
        System.out.println(System.currentTimeMillis());

static void exit(int status) 终止当前运行的Java虚拟机。

for (int i = 0; i < 10; i++) {
            System.out.println(i);
            if (i == 5){
                //表示终止当前正在运行的Java虚拟机，也就是结束程序
                //一般，非0的状态码表示异常终止
                System.exit(0);
            }
        }

static void gc() 运行垃圾回收器。

结合finalize()方法，观察gc()方法对于垃圾对象的回收，只有没有被引用的对象才会被gc()方法明确的回收

public class Student implements Cloneable {
   
    @Override
    protected void finalize() throws Throwable {
        System.out.println("对象被回收了,finalize()方法自动被调用了！");
    }
}


public class TestStudent {
    public static void main(String[] args) throws CloneNotSupportedException {
      
        Student s1 = new Student();
         new Student();
         new Student();
         new Student();
         System.gc();
    }
}

包装类(会用)

概念：基本数据类型，没有方法可以使用，将来如果需要完成基本数据类型的转换，不太方便，所以系统就提供了包装类，包装类其实就是将基本类型，以对象的形式表示出来，提供了一些方法，可以调用，从而是基本类型间接的使用对象的方法。

将来Java集合中，只能存放对象，所以想要在集合中存入基本数据类型，必须要以包装类的形式存放

基本数据类型对应的包装类：

byte => Byte

short => Short

int =>Integer

long =>long

float =>Float

Float(float value) 构造一个新分配的 Float对象，该对象表示基元 float参数。

Float(String s) 构造一个新分配 Float对象，它表示类型的浮点值 float用字符串表示。

double => Double

char => Character

Character(char value) 构造一个新分配的 Character对象，代表指定的 char值。

boolean =>Boolean

包装类的特点：

1，构造方法：除了Character类以外，其他的包装类，都可以以它基本类型的数据或者一个字符串作为参数，来构造对应的包装类对象

2，普通方法：包装类通用的一些方法

//1,XXXValue:将包装类转为基本类型

//2,toString() 将包装类以字符串的形式返回

//3,valueOf() 包装类都有一个valueOf方法，通过类名直接调用，传入字符串或者基本类型，返回包装类型

注意，传入字符串的时候，不能随便传，要符合对应的类型

//4,parseXXX : 将字符串转换为对应包装类的基本数据类型

public class Demo01 {
    public static void main(String[] args) {

        Integer i1 = new Integer(123);
        //1,XXXValue:将包装类转为基本类型
        int i2 = i1.intValue();
        //2,toString() 将包装类以字符串的形式返回
        String i3 = i1.toString();
        //3,valueOf()  包装类都有一个valueOf方法
        //通过类名直接调用，传入字符串或者基本类型，返回包装类型
        //注意，传入字符串的时候，不能随便传，要符合对应的类型
        Integer i4 = Integer.valueOf("100");

        //4,parseXXX  : 将字符串转换为对应包装类的基本数据类型
        int i5 = Integer.parseInt("100");


        Float f1 = new Float(3.3);
        //1,XXXValue:将包装类转为基本类型
        float f2 = f1.floatValue();

        Boolean b1 = new Boolean(true);
        //1,XXXValue:将包装类转为基本类型
        boolean b2 = b1.booleanValue();

        Character c1 = new Character('A');
        //1,XXXValue:将包装类转为基本类型
        char c2 = c1.charValue();
        //Character类的valueof没有字符串类型的参数
        Character.valueOf('a');
    }
}

jdk1.5新特性：自动装箱和自动拆箱

    	//创建包装类对象
        //Integer i = new Integer(100);
        
        //自动装箱，将基本类型的值，直接赋值给对应的包装类对象
        //系统其实省略一个步骤： 
        //Integer.valueOf(100);
        Integer i = 100;
        Character c = 'a';
        
        //自动拆箱,将包装类型的对象，直接赋值给对应基本类型变量
        //中间省略调用intValue()方法这个步骤
        //int i1 = i.intValue();
        int a = i;  //直接把包装类对象，赋值给基本类型的变量

Integer类型

构造方法:

Integer(int value) 构造一个新分配的 Integer对象，该对象表示指定的 int值。

Integer(String s) 构造一个新分配 Integer对象，表示 int由指示值 String参数

普通方法：

static String toBinaryString(int i) 在基数2中返回整数参数的字符串表示形式为无符号整数。

static String toHexString(int i) 返回整数参数的字符串表示形式，作为16位中的无符号整数。

static String toOctalString(int i) 在基数8中返回整数参数的字符串表示形式为无符号整数。

String和int类型的转换：

    	// int  -> String
        int num = 100;
        //方式1：
        String s1 = num + "";
        //方式2:
        String s2 = String.valueOf(num);
        //方式3：   int -> Integer -> String
        Integer i = new Integer(num);
        String s3 = i.toString();
        //方式4： 
        String s4 = Integer.toString(num);
        
        
        //String->int
        
        String str = "200";
        //方式1:
        int i1 = Integer.parseInt(str);
        
        //方式2：
        Integer integer = new Integer(str);
        int i2 = integer.intValue();

Integer类的缓冲区

 //如果Integer对象的值，以值形式直接赋值的话
        //值在-128~127 的范围内，数值会从 缓冲区中直接拿取，
        // 判断对象是否相等，返回true
        //超过这个返回，判断相等返回false
        Integer i1 = 127;
        Integer i2 = 127;

        System.out.println(i1 == i2); //true

        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i3 == i4); //false

Character类

Character类包装一个对象中的基本类型char的值。类型为Character的对象包含一个单一字段，其类型为char 。

此外，该类还提供了几种方法来确定字符的类别（小写字母，数字等），并将字符从大写转换为小写，反之亦然。

构造方法：

Character(char value) 构造一个新分配的 Character对象，代表指定的 char值。

普通方法：

static boolean isDigit(char ch) 确定指定的字符是否是数字。

static boolean isLetter(char ch) 确定指定的字符是否是一个字母。

static boolean isLowerCase(char ch) 确定指定的字符是否是小写字符。

static boolean isUpperCase(char ch) 确定指定的字符是否为大写字符。

static String toString(char c) 返回一个 String对象，表示指定的 char 。

static char toLowerCase(char ch) 使用UnicodeData文件中的大小写映射信息将字符参数转换为小写。

static char toUpperCase(char ch) 使用UnicodeData文件中的案例映射信息将字符参数转换为大写

/*
测试Character类的常用方法
 */
public class Demo05 {
    public static void main(String[] args) {
        //char c = 'a';
        //System.out.println(Character.isDigit(c));// false
        //System.out.println(Character.isLowerCase(c));// true
        //System.out.println(Character.isUpperCase(c));// false
        //System.out.println(Character.isLetter(c));//true
        //System.out.println(Character.toUpperCase(c));//A
        //System.out.println(Character.toLowerCase(c));//a

        //让用户输入一段字符串数字加大小写字母混合，比如：asgsa2412fafGVSD312dfa
        //这段字符串中，有几个数字、几个小写字母、几个大写字母

        //1,创建输入对象，输入字符串，声明字符串
        String s = "asgsa2412fafGVSD312dfa";
        //2，将字符串转成字符数组
        char[] chars = s.toCharArray();
        //3，遍历数组
        //声明统计变量，三个
        int a = 0, b = 0, c = 0;
        for (int i = 0; i < chars.length; i++) {
            //3.1判断每个字符是什么，数字、小写字母、大写字母
            char ch = chars[i];
            //3.2判断之后给对应的统计变量做++
            if (Character.isDigit(ch)) { //如果是数字
                a++;
            }
            if (Character.isLowerCase(ch)){ //如果是小写字母
                b++;
            }
            if (Character.isUpperCase(ch)){ //如果是大写字母
                c++;
            }
        }
        //4，输出统计变量
        System.out.println("数字:" + a + ",小写字母：" + b + ",大写字母：" +c);
    }
}

其他类

Math类

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

常用方法：

static double ceil(double a) 返回大于或等于参数的最小（最接近负无穷大） double值，等于一个数学整数。

static double floor(double a) 返回小于或等于参数的最大（最接近正无穷大） double值，等于一个数学整数

static int max(int a, int b) 返回两个 int值中的较大值。

static int min(int a, int b) 返回两个 int的较小值。

static double random() 返回值为 double值为正号，大于等于 0.0 ，小于 1.0 。

static long round(double a) 返回参数中最接近的 long ，其中 long四舍五入为正无穷大。

//Math演示
public class Demo06 {
    public static void main(String[] args) {

        System.out.println(Math.ceil(3.25)); // 4
        System.out.println(Math.floor(3.25)); //3
        System.out.println(Math.max(10,10.2)); //10.2
        System.out.println(Math.min(10,5));  //5
        System.out.println(Math.round(2.58));//3

        System.out.println(Math.random());

        //通过random()方法得到1-10之间的随机整数
        System.out.println(Math.ceil(Math.random() * 10));

        //11-20之间随机整数
        System.out.println(Math.ceil(Math.random() * 10 + 10));
    }
}

Random

生成随机数的类

构造方法：

Random() 创建一个新的随机数生成器。

Random(long seed) 使用单个 long种子创建一个新的随机数生成器。

普通方法：

int nextInt() 返回下一个伪随机数，从这个随机数发生器的序列中均匀分布 int值。

int nextInt(int bound) 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。

protected int next(int bits) 生成下一个伪随机数。

long nextLong() 返回下一个伪，均匀分布 long从这个随机数生成器的序列值

//Random类
public class Demo07 {
    public static void main(String[] args) {
        //无参构造的random对象
        Random random = new Random();
        int i = random.nextInt();
        System.out.println(i);
        int i1 = random.nextInt(100);
        System.out.println(i1);

        Random random1 = new Random(2000);
        int i2 = random1.nextInt();
        System.out.println(i2);
        int i3 = random1.nextInt(100);
        System.out.println(i3);
    }
}

练习：

//写一个猜数字的小游戏

//提示用户，1-100随机数已经生成，让用户输入数值猜生成随机数大小

//如果猜小了，返回你猜小了

//猜大了，返回你猜大了

//猜中了，返回你猜对了，太棒了

//超过10次为猜中，游戏技术，并返回你太菜了，10次都没猜中！告诉他正确答案

BigInteger

大整数的运算

/*
BigInteger类
 */
public class Demo08 {
    public static void main(String[] args) {
        //Integer i = 1234567;
        //i = i * 54321;
        //System.out.println(i);
        //System.out.println(Integer.MAX_VALUE);
        Integer i1 = new Integer("2147483647");
        System.out.println(i1);
        //Integer i2 = new Integer("2147483648");
        //System.out.println(i2);
        BigInteger bi = new BigInteger("2147483648");
        System.out.println(bi);
        //System.out.println(bi + 100);  //不能直接使用加号

        BigInteger bi2 = new BigInteger("100");
        //BigInteger add(BigInteger val)
        //返回值为 (this + val)
        System.out.println(bi.add(bi2));
        //BigInteger divide(BigInteger val)
        //返回值为 (this / val) 。
        System.out.println(bi.divide(bi2));
        //BigInteger multiply(BigInteger val)
        //返回值为 (this * val) 。
        System.out.println(bi.multiply(bi2));

        //BigInteger subtract(BigInteger val)
        //返回值为 (this - val) 。
        System.out.println(bi.subtract(bi2));
        //int intValue()
        //将此BigInteger转换为 int  
        //如果bigInteger超过了范围,转为int之后,值会发生改变
        int i = bi.intValue();
        System.out.println(i);
    }
}

BigDecimal

主要用来做浮点数的运算，防止精度丢失

构造方法

BigDecimal(String val) 将BigDecimal的字符串表示 BigDecimal转换为 BigDecimal 。

BigDecimal(int val) 将 int成 BigDecimal 。

BigDecimal(double val) 将 double转换为 BigDecimal ，这是 double的二进制浮点值的精确十进制表示。

public class Demo09 {
    public static void main(String[] args) {

       // new BigDecimal();
        System.out.println(1-0.01);
        System.out.println(0.09 + 0.01);
        System.out.println(1.015 * 100);

        //创建BigDecimal对象
        BigDecimal b1 = new BigDecimal("0.09");
        BigDecimal b2 = new BigDecimal("0.01");

        System.out.println(b1.add(b2));
        System.out.println(b1.subtract(b2));
        System.out.println(b1.multiply(b2));
        System.out.println(b1.divide(b2));
    }
}

String类

String类用来表示字符串，所有的字符串都可以看做是String类的实例(对象)

String类的字符串，其实底层就是char类型的数组

String类声明的字符串是不可变的，它们的值在创建后不能被更改，如果字符串值被改变，那么其实是字符串变量对应的引用改变

构造方法：

String() 初始化新创建的 String对象，使其表示空字符序列。

String(byte[] bytes) 通过使用平台的默认字符集解码指定的字节数组来构造新的 String

String(char[] value) 分配一个新的 String ，以便它表示当前包含在字符数组参数中的字符序列。

String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。

String(StringBuffer buffer) 分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。

String(StringBuilder builder) 分配一个新的字符串，其中包含当前包含在字符串构建器参数中的字符序列。

普通方法：

char charAt(int index) 返回 char指定索引处的值。

String concat(String str) 将指定的字符串连接到该字符串的末尾。

boolean contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时才返回true。

boolean equals(Object anObject) 将此字符串与指定对象进行比较。

boolean equalsIgnoreCase(String anotherString) 将此 String与其他 String比较，忽略大小写

int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。

int indexOf(String str, int fromIndex) 返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。

boolean isEmpty() 返回 true如果，且仅当 length()为 0 。

int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。

int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。

int length() 返回此字符串的长度。

String replace(char oldChar, char newChar)

返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。

String replaceAll(String regex, String replacement)

用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。

String replaceFirst(String regex, String replacement)

用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。

String[] split(String regex)

将此字符串分割为给定的 regular expression的匹配。

String substring(int beginIndex)

返回一个字符串，该字符串是此字符串的子字符串。

String substring(int beginIndex, int endIndex)

返回一个字符串，该字符串是此字符串的子字符串。

char[] toCharArray()

将此字符串转换为新的字符数组。

String toLowerCase()

将所有在此字符 String使用默认语言环境的规则，以小写。

String toUpperCase()

将所有在此字符 String使用默认语言环境的规则大写。

String trim()

返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。

public class StringDemo01 {
    public static void main(String[] args) {
        String s = "abcdefabcd";
        //char charAt(int index) 	返回 char指定索引处的值。
        System.out.println(s.charAt(3)); // d

        //String concat(String str) 	将指定的字符串连接到该字符串的末尾。
        String s1 = s.concat("test");
        System.out.println(s1);

        //boolean contains(CharSequence s) 	当且仅当此字符串包含指定的char值序列时才返回true。
        System.out.println(s.contains(s1));


        //boolean equals(Object anObject) 	将此字符串与指定对象进行比较。
        System.out.println("abcd".equals(s));

        //boolean equalsIgnoreCase(String anotherString) 	将此 String与其他 String比较，忽略大小写
        System.out.println("abCdEfAbcd".equalsIgnoreCase(s));


        //int indexOf(String str) 	返回指定子字符串第一次出现的字符串内的索引。
        System.out.println(s.indexOf("d"));
        //int indexOf(String str, int fromIndex) 	返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
        System.out.println(s.indexOf("d",4));

        //boolean isEmpty() 	返回 true如果，且仅当 length()为 0 。
        System.out.println(s.isEmpty());

        //int lastIndexOf(String str) 	返回指定子字符串最后一次出现的字符串中的索引。
        System.out.println(s.lastIndexOf("d"));
        //int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。
        System.out.println(s.lastIndexOf("d",2));

        //int length() 	返回此字符串的长度。
        //数组有没有length()方法，字符串有没有length属性

        System.out.println(s.length());
        //String replace(char oldChar, char newChar)
        //将旧字符串替换为新的
        //"abcdefabcd"
        String s2 = s.replace("abc", "ABC");
        System.out.println(s2);

        //String replaceAll(String regex, String replacement)
        //用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。

        //String replaceFirst(String regex, String replacement)
        //用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。
        String s3 = s.replaceFirst("abc", "ABC");
        System.out.println(s3);

        //String[] split(String regex)
        //将此字符串分割为给定的 regular expression的匹配。
        String[] s4 = s.split("");
        System.out.println(Arrays.toString(s4));
        String[] s5 = s.split("b");
        System.out.println(Arrays.toString(s5));

        //String substring(int beginIndex)
        //返回一个字符串，该字符串是此字符串的子字符串。
        //String substring(int beginIndex, int endIndex)
        //返回一个字符串，该字符串是此字符串的子字符串。

        System.out.println(s.substring(3));
        System.out.println(s.substring(3,6));

        //char[] toCharArray()
        //将此字符串转换为新的字符数组。

        //String toLowerCase()
        //将所有在此字符 String使用默认语言环境的规则，以小写。
        //String toUpperCase()
        //将所有在此字符 String使用默认语言环境的规则大写。

        System.out.println(s.toUpperCase());
        //String trim()
        //返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。
        String s6 = "    adsag           ";
        System.out.println(s6);
        System.out.println(s6.trim());
    }
}

使用String中的方法，

求：一串大的字符串"adagjavagawegjavafwnaljavafwjavaafjava"中小字符串"java" 出现的次数。

public class StringDemo02 {
    public static void main(String[] args) {
        //求 ： 一串大的字符串"adagjavagawegjavafwnaljavafwjavaafjava"
        // 中小字符串"java" 出现的次数。

        //将小字符的长度，带入大字符串中去截取，替换原来的大字符串，如此循环

        String str1 = "adagjavagawegjavafwnaljavafwjavaafjava";
        String str2 = "java";
        //先去找java在大字符串中，第一次出现的位置 ,如果能找到，index ！= -1
        int index = str1.indexOf(str2);
        int count = 0;
        while (index != -1){
            count ++; //统计变量自增
            //将大字符串截取后，替换原来的大字符串
            str1 = str1.substring(index + str2.length());
            index = str1.indexOf(str2);
        }
        System.out.println(count);
    }
}

把字符串 "abcdefg"做翻转后输出

public class StringDemo03 {
    public static void main(String[] args) {
        //把字符串 "abcdefg"做翻转后输出
        //先转数组
        //从后向前遍历,做拼接
        String s = "abcdefg";
        char[] chars = s.toCharArray();
        String s1 = "";
        for (int i = chars.length-1; i >=0 ; i--) {
            s1 += chars[i];
        }
        System.out.println(s1);
    }
}

StringBuffer类
StringBuffer是一个字符串缓冲区类
String类型声明的字符串，不可变，所以每次拼接字符串的时候，都会产生新的引用，所以，使用String来完成字符串拼接，比较消耗资源
所以，Java中提供了这个StringBuffer类，让我们可以用来完成字符串拼接等其他的操作
构造方法
StringBuffer() 
构造一个没有字符的字符串缓冲区，初始容量为16个字符。  
StringBuffer(CharSequence seq) 
构造一个包含与指定的相同字符的字符串缓冲区 CharSequence 。  
StringBuffer(int capacity) 
构造一个没有字符的字符串缓冲区和指定的初始容量。  
StringBuffer(String str) 
构造一个初始化为指定字符串内容的字符串缓冲区。  
普通方法
StringBuffer append(CharSequence s) 	追加指定的 CharSequence到这个序列。
 int capacity() 	返回当前容量。 
StringBuffer delete(int start, int end) 	删除此序列的子字符串中的字符。  
StringBuffer insert(int offset, String str) 	将字符串插入到此字符序列中。  
StringBuffer reverse() 	导致该字符序列被序列的相反代替。
String toString() 	返回表示此顺序中的数据的字符串。

public class StringBufferDemo {
    public static void main(String[] args) {
        //创建缓冲区对象
        StringBuffer sb1 = new StringBuffer("abcd");

        System.out.println(sb1);

        StringBuffer sb2 = sb1.append("abcdefgh");
        System.out.println(sb2);
        System.out.println(sb1);
        //sb1 == sb2  返回true，说明新的内容是直接添加在原来的内容中的
        //也就是堆中的区域并没有改变，地址也没有变化
        System.out.println(sb1 == sb2);  //true
        //空间大小受构建对象时候传入的参数个数影响
        System.out.println(sb1.capacity());

        //删除也是在原对象基础上删除
        StringBuffer sb3 = sb1.delete(4, 6); //删除4,5
        System.out.println(sb3);
        System.out.println(sb1);

        //insert插入,指定位置插入
        sb1.insert(2,"hello");
        System.out.println(sb1);

        //翻转
        sb1.reverse();
        System.out.println(sb1);
    }
}

StringBuffer和String拼接字符串效率对比

public class StringBufferDemo01 {
    public static void main(String[] args) {
       //给String  拼接 10000次字符串
        long start = System.currentTimeMillis();
        String s = "hello";
        for (int i = 0; i < 10000; i++) {
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        //给StringBuffer拼接10000次字符串
        long start1 = System.currentTimeMillis();
        StringBuffer sb1 = new StringBuffer("hello");
        for (int i = 0; i < 100000; i++) {
            sb1.append(i);
        }
        long end1 = System.currentTimeMillis();
        System.out.println(end1 - start1);


        long start2 = System.currentTimeMillis();
        StringBuilder sb2 = new StringBuilder("hello");
        for (int i = 0; i < 100000; i++) {
            sb2.append(i);
        }
        long end2 = System.currentTimeMillis();
        System.out.println(end2 - start2);
    }
}

String、StringBuffer、StringBuilder的区别

String声明的字符不可变，可以看做是字符串常量，String的内容一旦改变，引用就改变了，可以看成是一个新的引用，所以，String类型做字符串拼接，比较耗时

StringBuffer称为字符串缓冲区，提供了一些方法，可以改变该缓冲区中的数据，但是对应的引用没有改变，相对来说StringBuffer效率更快

StringBuffer和StringBuilder ，他们都是字符串缓冲区，只不过StringBuffer的方法多了一个 synchronized关键字，它是线程安全的。多线程情况下，用StringBuffer，单线程就用StringBuilder

String 和 StringBuffer的转换

String类型转换为StringBuffer一般是为了使用StringBuffer类型的方法

将来程序中需要的还是String，所以还得转回来

public class StringBufferDemo02 {
    public static void main(String[] args) {
        //string ->stringbuffer
        String s = "hello";
        //直接赋值，强制转换都不行
        //StringBuffer sb1 = (StringBuffer) s;

        //1,通过构造方法
        StringBuffer sb1 = new StringBuffer(s);

        //2,通过append方法
        StringBuffer sb2 = new StringBuffer();
        sb2.append(s);


        //StringBuffer -> String
        //1,通过String类的构造方法
        String s1 = new String(sb1);
        
        //2,通过toStrig()方法
        String s2 = sb1.toString();
    }
}

让用户输入一段字符串，判断字符串是否是对称字符串，比如 aba ，abcdcba 就是对称字符串

Date类

Date类分为两个包，一个是sql包下的Date，一个是util包下的Date

sql包下的Date一般表示毫秒值，用来连接jdbc的时候，可以直接以字符串形式获取数据库中的时间

util包下的Date，一般用来表示生活中的时间格式，目前学习这个Date

构造方法

Date()

分配一个 Date对象，并初始化它，以当前时间创建一个Date对象

Date(long date)

分配一个 Date对象，传入一个毫秒值，根据毫秒值来创建Date对象

         //创建日期类型 ：
        //1，无参构造
        Date date = new Date();
        System.out.println(date);

        //2,使用毫秒值
        long time = System.currentTimeMillis();
        Date date1 = new Date(time);
        System.out.println(date1);

普通方法

long getTime() 返回当前Date对象的毫秒值

void setTime(long time) 设置此 Date对象以表示1970年1月1日00:00:00 GMT后的 time毫秒的时间点。

String toString() 将此 Date对象转换为 String的形式：

String toLocaleString()

    	 System.out.println(date.getTime()); //毫秒值

        System.out.println(date.getYear()+1900);
        System.out.println(date.getMonth()+1);
        System.out.println(date.getDate());
        System.out.println(date.getDay()); //星期几
        System.out.println(date.getHours());
        System.out.println(date.getMinutes());
        System.out.println(date.getSeconds());

DateFormat类

DateFormat是日期/时间格式化子类的抽象类

将来如果需要转换时间日期格式，一般使用它的子类 SimpleDateFormat

SimpleDateFormat是一个具体的类，一般用来完成字符串日期和Date日期类型之间的格式转换

构造方法

SimpleDateFormat()

构造一个 SimpleDateFormat使用默认模式和日期格式符号为默认的 FORMAT区域设置。

SimpleDateFormat(String pattern)

使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。

常用方法

String format(Date date)

将日期格式化成日期/时间字符串。

Date parse(String source)

从给定字符串的开始解析文本以生成日期。

public class DemoFormat {
    public static void main(String[] args) throws ParseException {
        //通过SimpleDateFormat完成Date和String之间的转换

        //Date->String
        //创建当前的时间对象
        Date date = new Date();
        //创建日期格式化对象
        SimpleDateFormat sdf =
                new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //调用方法
        String stringTime = sdf.format(date);
        System.out.println(stringTime);

        //String-> Date
        //声明一个字符串时间格式
        String time = "2022-07-22 10:10:10";
        Date date1 = sdf.parse(time);
        System.out.println(date1);
    }
}

计算出生天数

//让用户输入自己的生日，然后看看自己已经出生多少天了
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的生日,参考格式：1999-11-11");
//接受生日输入
String birthday = scanner.next();

//生日转为Date，然后获取时间戳(毫秒值)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

Date date = sdf.parse(birthday);

long time = date.getTime(); //获取毫秒值

long timeNow = System.currentTimeMillis();

//计算天数
long day = (timeNow - time) /1000/60/60/24;
System.out.println("天数" + day);

日期转换工具类

//日期工具类
public class DateUtil {
    //日期转字符串方法
    // 返回值 ：String
    //参数 ：日期，格式
    public static String dateToString(Date date,String pattern){
        return new SimpleDateFormat(pattern).format(date);
    }

    //字符串转日期方法
    // 返回值 ：Date
    //参数 ：String日期，格式
    public static Date stringToDate(String date,String pattern) throws ParseException {
        return new SimpleDateFormat(pattern).parse(date);
    }
}

Calendar

常用的日历抽象类，提供了一些常用日期时间中的属性、以及一些转换的方法

常用方法

int get(int field) 返回给定日历字段的值。

static Calendar getInstance() 使用默认时区和区域设置获取日历对象。

String toString() 返回此日历的字符串表示形式。

public class CalendarDemo {
    public static void main(String[] args) throws ParseException {
        //Calendar类是抽象类，不能直接new，通过getInstance方法创建对象

        Calendar calendar = Calendar.getInstance();
        //传入的是Calendar类中的属性
        int year = calendar.get(Calendar.YEAR);
        //int year1 = calendar.get(1);
        System.out.println(year);
        //System.out.println(year1);

        System.out.println(calendar.get(Calendar.MONTH)+1); //月份+1
        System.out.println(calendar.get(Calendar.DATE)); //日期
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK)-1); //周几获取-1
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR)); //一年的第多少天
        System.out.println(calendar.get(Calendar.HOUR)); // 时
        System.out.println(calendar.get(Calendar.MINUTE)); //分
        System.out.println(calendar.get(Calendar.SECOND)); //秒

        //获取某个指定时间
        //Date date = DateUtil.stringToDate("2000-10-10", "yyyy-MM-dd");
        //calendar.setTime(date);
        //System.out.println(calendar.get(Calendar.YEAR));
        //System.out.println(calendar.get(Calendar.MONTH)+1); //月份+1
        //System.out.println(calendar.get(Calendar.DATE)); //日期
        //System.out.println(calendar.get(Calendar.DAY_OF_WEEK)-1); //周几获取-1
        //System.out.println(calendar.get(Calendar.DAY_OF_YEAR)); //一年的第多少天
        //System.out.println(calendar.get(Calendar.HOUR)); // 时
        //System.out.println(calendar.get(Calendar.MINUTE)); //分
        //System.out.println(calendar.get(Calendar.SECOND)); //秒

        //abstract void add(int field, int amount)
        //根据日历的规则，将指定的时间量添加或减去给定的日历字段。
        //获取三年前的今天

       // calendar.add(Calendar.YEAR,-3);
       // System.out.println(calendar.get(Calendar.YEAR));
       // System.out.println(calendar.get(Calendar.MONTH)+1);

        //3年后的，10天前
        calendar.add(Calendar.YEAR,3);
        calendar.add(Calendar.DATE,-10);

        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH)+1);
        System.out.println(calendar.get(Calendar.DATE));
    }
}

//利用日历类，完成时间的获取

//在计费系统中，需要计算两个时间的时间差，比如停车时间

// 从 7:30 进入停车场， 8：35分离场，每15分钟收费1块钱

//计算我需要交费多少钱

public class CalendarDemo02 {
    public static void main(String[] args) throws ParseException {
        //利用日历类，完成时间的获取
        //在计费系统中，需要计算两个时间的时间差，比如停车时间
        // 从 7:30 进入停车场， 8：35分离场，每15分钟收费1块钱
        //计算我需要交费多少钱

        // 字符串时间对应的Date对象
        String time1 = "07:30";
        String  time2 = "08:35";
        Date startDate = DateUtil.stringToDate(time1, "HH:mm");
        Date endDate = DateUtil.stringToDate(time2, "HH:mm");
        //设置日历类的时间
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        // 通过日历类分别获取到 开始时间的小时和分钟
        c1.setTime(startDate);
        int startHour = c1.get(Calendar.HOUR);
        int startMinute = c1.get(Calendar.MINUTE);
        //获取结束时间的小时和分钟
        c2.setTime(endDate);
        int endHour = c2.get(Calendar.HOUR);
        int endMinute = c2.get(Calendar.MINUTE);
        //计算总时间,计算价格

        int money = ((endHour * 60 + endMinute) - (startHour * 60 + startMinute))/15 * 1;

        System.out.println(money);

    }
}

正则表达式

指的是符合一定规则的字符串，用来约束某些信息，在编写的时候，遵守指定的规则

正则的编写规范：

1，字符格式

a 表示匹配 a

[abc] 表示匹配 abc ，1次

[^abc] 表示除abc以外的，1次

[A-Z] 表示匹配大写字母 1次

[0-9] 表示匹配任意数字1次

[a-z] 表示匹配小写字母1次

[a-zA-Z0-9] 表示匹配大小写字母数字1次

2,次数格式

{n} 匹配指定的n次

{n,m} 匹配n到m次

{n,} 匹配最少n次，最高不限次数

? 一次或者0次

*0次或者多次

+1次或者多次

3，通配符

\转义符 ,将有特殊含义的字符转义为本来的含义

^表示以指定的内容

$表示以指定的内容结尾

\w 表示任意字符，相当于 [a-z_A-Z0-9]

\d 表示任意数字，相当于[0-9]

public class RegexDemo {
    public static void main(String[] args) {

        //测试用户输入的手机号码是否符合规范
        //声明一个手机号码的正则表达式
        String regex = "^[1][3-9]\\d{9}";
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个手机号码:");
        String phoneNum = sc.next();
        //调用方法，传入正则规则，判断是否符合
        boolean b = phoneNum.matches(regex);
        if (b){
            System.out.println("手机号符合规范");
        }else {
            System.out.println("手机号不符合规范");
        }
    }
}

public class RegexDemo02 {
    public static void main(String[] args) {

        //写一个邮箱的正则表达式   xxx@sohu.com.cn
        //String regex = "[0-9a-zA-Z]{3,16}@[0-9a-zA-Z]{2,10}(\\.[a-z]{2,3}){1,2}";
        String regex = "\\w{3,16}@\\w{2,10}(\\.\\w{2,3}){1,2}";

        Scanner sc = new Scanner(System.in);
        System.out.println("输入邮箱:");
        String s = sc.next();

        boolean b = s.matches(regex);
        if (b){
            System.out.println("符合规范");
        }else {
            System.out.println("不符合规范");
        }
    }
}

public class RegexDemo02 {
    public static void main(String[] args) {

        //写一个邮箱的正则表达式   xxx@sohu.com.cn
        //String regex = "[0-9a-zA-Z]{3,16}@[0-9a-zA-Z]{2,10}(\\.[a-z]{2,3}){1,2}";
        String regex = "\\w{3,16}@\\w{2,10}(\\.\\w{2,3}){1,2}";

        Scanner sc = new Scanner(System.in);
        System.out.println("输入邮箱:");
        String s = sc.next();

        boolean b = s.matches(regex);
        if (b){
            System.out.println("符合规范");
        }else {
            System.out.println("不符合规范");
        }
    }
}