7.String类、Random类、Date类

String类的使用

学习一个新的类，首先看构造方法，然后再看其他方法

构造方法

String()
初始化新创建的 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 lastIndexOf(String str)
返回指定子字符串最后一次出现的字符串中的索引。
int length()
返回此字符串的长度。
String replace(CharSequence target, CharSequence replacement)
将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。
String replaceAll(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。
String replaceFirst(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。
String substring(int beginIndex)
返回一个字符串，该字符串是此字符串的子字符串。
String substring(int beginIndex, int endIndex)
返回一个字符串，该字符串是此字符串的子字符串。
String toLowerCase()
将所有在此字符 String使用默认语言环境的规则，以小写。
String toUpperCase()
将所有在此字符 String使用默认语言环境的规则大写。
 

package com.day7.stringtest;

import java.util.Locale;

public class StringDemo01 {
    public static void main(String[] args) {
        String s="hello";
        String s1 = new String();
        String s2 = new String("hello");

        //char   charAt(int index)
        //返回 char指定索引处的值。
        //'h'对应的索引值是0
        char c = s.charAt(2);
        System.out.println(c);

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

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

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

        //boolean   equalsIgnoreCase(String anotherString)
        //将此 String与其他 String比较，忽略大小写。
        String s4="Hello";
        String s5="hello";
        System.out.println(s4.equalsIgnoreCase(s5));//true

        //int   indexOf(String str)
        //返回指定子字符串第一次出现的字符串内的索引。
        //s3=helloworld
        System.out.println(s3.indexOf("world"));//5
        System.out.println(s3.indexOf("o"));//4

        //int lastIndexOf(String str)
        //返回指定子字符串最后一次出现的字符串中的索引。
        System.out.println(s3.lastIndexOf("o"));//6

        //int   length()
        //返回此字符串的长度。
        System.out.println(s3.length());//10

        //String   replace(CharSequence target, CharSequence replacement)
        //将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。
        String s6 = s3.replace("o", "x");
        System.out.println(s6);//hellxwxrld

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

        //String   substring(int beginIndex)
        //返回一个字符串，该字符串是此字符串的子字符串。
        String s7 = s3.substring(5);
        System.out.println(s7);//world

        //String substring(int beginIndex, int endIndex)
        //返回一个字符串，该字符串是此字符串的子字符串。
        String s8 = s3.substring(3, 5);
        System.out.println(s8);//lo

        //String   toLowerCase()
        //将所有在此字符 String使用默认语言环境的规则，以小写。
        String s9 = s3.toLowerCase();
        System.out.println(s9);

        //String   toUpperCase()
        //将所有在此字符 String使用默认语言环境的规则大写。
        String s10 = s3.toUpperCase();
        System.out.println(s10);

    }
}

StringBuffer和StringBuilder

StringBuffer类就是一个字符串的缓冲区，提供了一些方法去修改字符串的长度和内容。
StringBuilder类提供与StringBuffer的API，但不保证同步。 不安全

String类型，声明的字符串内容是不可变的，将来想要改变字符串的内容，只能以字符串拼接的方式去改变内容，
字符串每次做拼接之后，其实都在改变原来引用，这个操作比较消耗资源。
所以，系统中提供了StringBuffer类，可以在不改变字符串引用的情况下去操作字符串，从而达到节省资源的目的。

StringBuffer和StringBuilder的方法都是一样的，唯一区别是StringBuffer中，都有synchronized这个修饰符，
它是线程安全的，StringBuilder是线程不安全的。
如果多线程操作，用StringBuffer。
在单线程中，使用StringBuffer和StringBuilder都可以。
 

StringBuffer类

构造方法

StringBuffer()
构造一个没有字符的字符串缓冲区，初始容量为16个字符。
StringBuffer(CharSequence seq)
构造一个包含与指定的相同字符的字符串缓冲区 CharSequence 。
StringBuffer(int capacity)
构造一个没有字符的字符串缓冲区和指定的初始容量。
StringBuffer(String str)
构造一个初始化为指定字符串内容的字符串缓冲区。

普通方法

StringBuffer append(String str)
将指定的字符串附加到此字符序列。
int capacity()
返回当前容量。
char charAt(int index)
返回 char在指定索引在这个序列值。
StringBuffer delete(int start, int end)
删除此序列的子字符串中的字符。
StringBuffer insert(int offset, String str)
将字符串插入到此字符序列中。
StringBuffer reverse()
导致该字符序列被序列的相反代替。

package com.day7.stringtest;

public class StringDemo02 {
    public static void main(String[] args) {
        //创建一个stringbuffer对象
        StringBuffer sbf = new StringBuffer();
        System.out.println(sbf);
        //有参构造创建一个
        StringBuffer sbf1 = new StringBuffer("hello");
        System.out.println(sbf1);


        //StringBuffer   append(String str)
        //将指定的字符串附加到此字符序列。
        StringBuffer sbf2 = sbf1.append("world");
        System.out.println(sbf2);
        System.out.println(sbf1);
        System.out.println(sbf1==sbf2);

        //int    capacity()
        //返回当前容量。
        System.out.println(sbf1.capacity());//21
        System.out.println(sbf.capacity());//16

        System.out.println(sbf1.length());//10
        //char    charAt(int index)
        // 返回 char在指定索引在这个序列值。

        //StringBuffer    delete(int start, int end)
        //删除此序列的子字符串中的字符。
        sbf1.delete(3,5);
        System.out.println(sbf1);
        //StringBuffer    insert(int offset, String str)
        //将字符串插入到此字符序列中。
        sbf1.insert(5,"mysql");
        System.out.println(sbf1);

        //StringBuffer    reverse()
        //导致该字符序列被序列的相反代替。
        sbf1.reverse();
        System.out.println(sbf1);
    }

}

效率对比

package com.day7.stringtest;

public class StringDemo03 {
    public static void main(String[] args) {
        //测试字符串拼接效率
        //拼接一万字符串，需要花费多长时间
        long start = System.currentTimeMillis();//返回当前时间的毫秒值
        String s="hello";
        for (int i = 0; i < 100000; i++) {
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("拼接10万字符串，需要"+(end-start)+"毫秒");


        long start1 = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("hello");
        for (int i = 0; i < 100000; i++) {
            sbf.append(i);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("StringBuffer拼接10万字符串，需要"+(end1-start1)+"毫秒");


        long start2 = System.currentTimeMillis();
        StringBuilder sbd = new StringBuilder("hello");
        for (int i = 0; i < 100000; i++) {
            sbd.append(i);
        }
        long end2 = System.currentTimeMillis();
        System.out.println("StringBuilder拼接10万字符串，需要"+(end2-start2)+"毫秒");

    }
}

Random类

构造方法

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

package com.day7.randomtest;

import java.util.Random;
import java.util.Scanner;

public class RandomDemo {
    public static void main(String[] args) {
        /*
        //无参构造创建的对象
        Random random = new Random();
        //有参构造创建的对象
        Random random1 = new Random(1000);
         */

        //系统随机生成一个1-100间的数字，这个数字在游戏期间不会改变
        Random random = new Random();
        int r= random.nextInt(100)+1;//[1-100]
        System.out.println(r);
        //用户通过输入信息，猜数字
        Scanner s = new Scanner(System.in);
        boolean flag=true;
        int count=0;
        //循环接收用户输入
        while (flag){
            //接收用户输入
            System.out.println("请输入一个1-100的整数");
            int i= s.nextInt();
            //如果用户猜小了，提示用户猜小了，
            if(i<r){
                System.out.println("猜小了！");
                count++;

            }else if (i>r){       //猜大就提示猜大了
                System.out.println("猜大了！");
                count++;
            }else {   //猜对就返回猜对了，并且返回你一共猜了几次
                System.out.println("猜对了！");
                count++;
                break;
            }
        }
        //如果超过10次，就返回，你是大笨蛋
        //如果不超过10次，就返回你太聪明了
        if(count<=10){
            System.out.println("你太聪明了！一共猜了"+count+"次！");
        } else{
            System.out.println("你是大笨蛋！一共猜了"+count+"次！");
        }
    }
}

Date类

构造方法

Date()
分配一个 Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。
Date(long date)
分配一个 Date对象，传入一个毫秒值作为参数，来创建日期对象，
即1970年1月1日00:00:00 GMT。

普通方法

long getTime()
返回自1970年1月1日以来，由此 Date对象表示的00:00:00 GMT的毫秒数 。

package com.day7.datetest;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //返回当前时间的，时间对象
        Date date = new Date();
        System.out.println(date);

        //date对象有一个getTime()方法，可以获取到日期对象的毫秒数
        System.out.println(date.getTime());

        System.out.println(date.getYear()+1900);
        System.out.println(date.getHours());
        System.out.println(date.toString());
        System.out.println(date.toLocaleString());

        //传入一个毫秒值，创建时间对象
        //返回的时间是1970-1-1 00：00：00 加上 传入的毫秒值
        Date date1 = new Date(1000);
        System.out.println(date1);

        //计算出生天数
        //定义生日值  2000-7-5
        String birth="2000-7-5";
        //创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        //调用方法做转换，字符串转日期
        Date date2=sdf.parse(birth);
        System.out.println(date2.toLocaleString());

        //调用方法，日期转字符串
        String s = sdf.format(date);
        System.out.println(s);

    }
}

SimpleDateFormat类

是一个日期格式化类，可以使用用户定义的格式，完成字符串和日期Date类的转换

构造方法

SimpleDateFormat()
构造一个 SimpleDateFormat使用默认模式和日期格式符号为默认的 FORMAT区域设置。
SimpleDateFormat(String pattern)
使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。
SimpleDateFormat(String pattern, DateFormatSymbols formatSymbols)
使用给定的模式和日期格式符号构造一个 SimpleDateFormat 。
SimpleDateFormat(String pattern, Locale locale)
构造一个 SimpleDateFormat使用给定的模式和给定的区域设置的默认日期格式符号。

普通方法

String format(Date date)
将给定的 Date成日期/时间字符串
Date parse(String text, ParsePosition pos)
从字符串中解析文本以产生一个 Date 。

package com.day7.datetest;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class DateDemo01 {
    public static void main(String[] args) throws ParseException {
        //让用户输入生日，计算出生天数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的生日：");
        String birthday = scanner.next();
        //输入的字符串转日期
        //创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd");
        Date birthdate = sdf.parse(birthday);
        //生日毫秒值
        long t1 = birthdate.getTime();
        返回当前时间的，时间对象
        Date date = new Date();
        //当前日期毫秒值
        long t2 = date.getTime();
        //相差毫秒值
        long t =t2-t1;
        //相差天数
        long d=t/1000/60/60/24;
        System.out.println("你的出生天数为"+d);
    }
}