String类、Date、IO流

一、String 类
1.String类较常用构造方法:
String(s)，
String (char a[ ])，
String(char a[ ],int startIndex,int count)

2.String 类的常用方法
public boolean startsWith(String s)
public boolean endsWith(String s) :判断当前字符串对象的前缀（后缀）是否是参数s指定的字符串
public int compareTo(String s):按字典序与参数s指定的字符串比较大小
public int compareToIgnoreCase(String s)
public boolean contains(String s):判断当前字符串对象是否含有参数指定的字符串 s
public int indexOf (String s):从当前字符串的头开始检索字符串 s，并返回首次出现 s 的位置
int indexOf(String s ,int startpoint)
int lastIndexOf (String s)
public String substring(int startpoint):获得一个当前字符串的子串
String substring(int start ,int end)
public String trim(): 得到一个 去掉前后空格后 的字符串对象
String[ ] split(String regex)：以regex切割字符串，形成字符串数组
String replace (String old, String new)：替换字符串

3.字符串与基本数据的相互转化
public static int parseInt(String s)：可以将由“数字”字符组成的字符串
类似地,使用java.lang包中的 Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符 组成的字符串，转化为相应的 基本数据类型。

4.字符串与字符、字节数组
字符串与字符数组：
String 类的构造方法：String(char[ ]) 和 String(char[ ]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象
String类提供了将字符串存放到数组中的方法：public void getChars(int start,int end,char c[ ],int offset )
将字符串中的全部字符存放在一个字符数组中的方法：public char[ ] toCharArray()

5.字符串与字节数组
String(byte[])用指定的字节数组构造一个字符串对象。
String(byte[]，int offset，int length) 用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
public byte[] getBytes() 方法使用平台默认的字符编码，将当前字符串转化为一个字节数组。
public byte[] getBytes(String charsetName) 使用参数指定字符编码，将当前字符串转化为一个字节数组。
 

public class Text {
    public static void main(String[] args) {
//		//构建字符串对象
//		//字面量的方式构建字符串对象
//		String s = "hello";
//
//		//通过构造方法构建字符串对象
//		String s0 = new String("sss");
//
//		char[] c = new char[]{'a','b','c','d'};
//		String s1 = new String(c);
//		System.out.println(s1);
//
//		String s2 = new String(c, 1, 2);
//		System.out.println(s2);

        String s = "hello";

        System.out.println(s.startsWith("hel"));//判断当前的字符串是否是以某个字符串开头
        System.out.println(s.endsWith("lo"));//判断当前的字符串是否是以某个字符串结尾

        /**
         * s.compareTo(b)
         * 先比两个字符串的第一位字符，如果不同，就不用往下比，直接计算第一位的两个字符的差(字符的ASCII码的值的差)
         * 如果第一位相同，就比较第二位，如果不同，就不用往下比，直接计算第二位的两个字符的差
         * 依次往下比较
         * 如果在比较的过程中，字符串都相同，只是一个字符串比另一个字符串长，比如："abcd"与"abc"
         * 这样的情况就是计算两个字符串的长度的差(第一个字符串减去第二个字符串)
         * 字符串的compareTo方法是严格的区分大小写的
         * 如果返回值是0代表字符串相同
         */
        System.out.println(s.compareTo("Hello"));

        /**
         * String的compareToIgnoreCase与compareTo基本相同，唯一的不同点是compareToIgnoreCase不区分大小写
         */
        System.out.println(s.compareToIgnoreCase("Hello"));

//		System.out.println('h' - 'H');

        System.out.println("hello".contains("el"));//判断字符串是否含有某个字符串

        System.out.println("abcdebc".indexOf("bcd"));//判断一个"bcd"在"abcdebc"字符串中所处的位置，从0位开始

        System.out.println("abcdebc".indexOf("b",2));//从第2个元素开始判断"b"字符串在"abcdebc"字符串中的位置

        System.out.println("abcdebc".lastIndexOf("b"));//获取字符串"b"在"abcdebc"中最后一次出现的位置

        System.out.println("hello".substring(1));//从字符串"hello"的第1个位置向后截取到最后返回一个新的字符串

        System.out.println("hello".substring(1,3));//截取字符串"hello"的[1,3)区间的元素返回新的字符串

        System.out.println("   hello   ".trim());//去掉字符串前后的空格，返回新的字符串

        String str = "hello,world,!!";

        String[] strs = str.split(",");//可以按照指定字符串把一个字符串切割成字符串数组

        for(String ss : strs){
            System.out.println(ss);
        }

        System.out.println("abcde".replace("bc", "ppp"));//对字符串中子串进行替换，参数1是原有的字符串，参数2是替换的新字符串

    }
}

package day16;

import java.io.UnsupportedEncodingException;

public class Test1 {
	public static void main(String[] args) {
		String s = "10";
		
		int i = Integer.parseInt(s);
		
		System.out.println(i);
		
		System.out.println(Boolean.parseBoolean("true"));
		
		char[] c = new char[]{'a','b','c','d'};
		
		
		System.out.println(new String(c));
		
		System.out.println(new String(c,1,2));//从字符数组c的第一个元素开始，总共截取两个元素形成一个新的字符串
		
		char[] c1 = new char[10];
		
		"abcdef".getChars(1, 3, c1, 2);//从字符串"abcdef"中截取[1,3)区间的元素，放到c1字符数组中，从第2个位置开始放
		
		for(int m = 0; m < c1.length; m++){
			System.out.println("第" + m + "个元素:" + c1[m]);
		}
		
		char[] c2 = "abcdef".toCharArray();//把字符串转化为字符数组
		
		for(int m = 0; m < c2.length; m++){
			System.out.println("第" + m + "个元素:" + c2[m]);
		}
		
		byte[] b = "abcd".getBytes();//把字符串转化为字节数组,转化的编码格式是平台默认的编码，目前默认是GBK
		
		System.out.println(new String(b));//把字节数组b转化为字符串
		
		System.out.println(new String(b,1,3));//把字节数组b转化为字符串，从b的第1个元素开始，总共截取3个元素来转化
		
		try {
			byte[] b1 = "abcd".getBytes("UTF-8");//把字符串按照指定的编码转化为字节数组
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		
	}
}

二.Date & DateFormat 类
Date类在java.util包中。使用Date类的无参数构造方法创建的对象可以获取本地当前时间。
SimpleDateFormat来实现日期的格式化。

public SimpleDateFormat(String pattern);
该构造方法可以用 参数pattern 指定的格式创建一个对象，该对象调用：

public String format(Date date)：方法格式化时间对象date
 

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test3 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        /**
         * yyyy代表年份
         * MM代表月份
         * dd代表日
         * HH代表小时
         * mm代表分钟
         * ss代表秒
         *
         * 格式化的分隔符可以自由定义
         *
         * 在格式化时候，可以把年月日时分秒单独拿出一个或者拿出其中几个来组合使用
         * 例如new SimpleDateFormat("yyyy-MM-dd");
         * new SimpleDateFormat("MM-dd");
         * new SimpleDateFormat("dd HH");
         *
         */

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        // DateFormat df = new SimpleDateFormat("HH");
		// DateFormat df = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
        String s = df.format(date);
        System.out.println(s);
    }
}

三.IO流

1.什么是IO流
IO流也称为输入输出流、就是用来读写数据的
I：input，是数据从硬盘文件读入到内存的过程，称之为输入，负责读
O：output，是内存程序的数据从内存到写出到硬盘文件的过程，称之输出、负责写

2.字节流：音频、视频文件
字符流：文本

3.IO流作用：读写文件数据

4.每次读取一个字节存在什么问题？
性能较慢
读取中文字符输出无法避免乱码问题

5.每次读取一个字节数组存在什么问题？
读取的性能得以提升
读取中文字符输出无法避免乱码问题

6.如何使用字节输入流读取中文内容不乱码？
定义一个与文件一样大的数组，一次性读取完文件的全部字节

7.直接把文件数据全部读取到一个字节数组怎样？
如果文件过大，字节数可能引起内存溢出

8.字节输出流如何实现写出去的数据能换行？
os.write("\r\n".getBytes());

9.如何让写出去的数据能成功生效？
flush();     //刷新数据
close();  //关闭流，关闭包含刷新，关闭后流不可以继续使用了

10.try-catch-finally
finally：在异常处理时提供finally块来执行所有清除操作，比如IO流中的释放资源
特点：被finally控制的语句最终一定会执行，除非JVM退出
异常的处理标准格式：try.....catch.....finally
finally代码块最终是一定要执行的，可以在代码执行完毕的最后释放资源

字符流的好处
1.读取中文字符不会出现乱码（如果文件和代码的编码一致）

2.每次读取一个字符的问题
性能较慢

3.文件字符输入流（FileReader）的作用
以内存为基准，把磁盘文件中的数据以字符的形式读取到内存中

4.每次读取一个字符的优势
读取的性能得到了提升，不会乱码

5.字节流、字符流如何选择使用
字节流适合做一切文件数据 的拷贝（音视频、文本）
字节流不适合读取中文内容输出
字符流适合做文本文件操作（读，写）

IO流综合案例

有5个学生有3门课的成绩，从键盘输入以上数据（包括学生姓名和三门课的成绩），输入的格式为zhangsan,30,40,50，
计算出总成绩，并把学生的信息和计算出的总分数按有高到低的顺序存放在磁盘文件a.txt中。
分析：
1.描述学生对象
2.定义一个可操作学生对象的工具类
思路：
1.通过获取键盘录入一行数据，并将该行中的数据取出封装成学生对象。
2.因为学生对象有很多，那么久需要存储，使用到集合。
又因为要对学生的总分进行排序，所以要使用TreeSet。
3.将集合中的信息写入到一个文件中。
 

public class Student implements Comparable<Student>{
    private String name;
    private int ma,cn,en;
    private int sum;

    public Student(String name, int ma, int cn, int en) {
        super();
        this.name = name;
        this.ma = ma;
        this.cn = cn;
        this.en = en;
        sum = ma + cn + en;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMa() {
        return ma;
    }
    public void setMa(int ma) {
        this.ma = ma;
    }
    public int getCn() {
        return cn;
    }
    public void setCn(int cn) {
        this.cn = cn;
    }
    public int getEn() {
        return en;
    }
    public void setEn(int en) {
        this.en = en;
    }
    public int getSum() {
        return sum;
    }
    public void setSum(int sum) {
        this.sum = sum;
    }
    @Override
    public int compareTo(Student s) {
        int num = new Integer(this.sum).compareTo(new Integer(s.sum));
        if(num==0)
            return this.name.compareTo(s.name);
        return num;
    }
    @Override
    public int hashCode() {
        return name.hashCode()+sum*31;
    }
    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student s = (Student)obj;
        return this.name.equals(s.name)&&this.sum==s.sum; 
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", ma=" + ma + ", cn=" + cn + ", en="
                + en + "]";
    }

}
public class StudentInfoTool {
    public static Set<Student> getStudents() throws IOException{
        return getStudents(null);
    }
    public static Set<Student> getStudents(Comparator<Student> cmp) throws IOException{
        BufferedReader bufr = new BufferedReader(
                new InputStreamReader(System.in));
        String line = null;
        Set<Student> stus = null;
        if(cmp==null)
            stus = new TreeSet<Student>();
        else
            stus = new TreeSet<Student>(cmp);
        while((line=bufr.readLine())!=null){
            if("over".equals(line))
                break;
            String[] info = line.split(",");
            Student stu = new Student(info[0],Integer.parseInt(info[1]),
                    Integer.parseInt(info[2]),Integer.parseInt(info[3]));
            stus.add(stu);
        }
        bufr.close();
        return stus;
    }
    public static void write2File(Set<Student> stus) throws IOException{
        BufferedWriter bufw = new BufferedWriter(
                new FileWriter("E:\\a.txt"));
        for(Student s :stus){
            bufw.write(s.toString()+"\t");
            bufw.write(s.getSum()+"");
            bufw.newLine();
            bufw.flush();
        }
        bufw.close();
    }
}
public class StudentInfoTest {
    public static void main(String[] args) throws IOException{
        Comparator<Student> cmp = Collections.reverseOrder();
        Set<Student> stus = StudentInfoTool.getStudents(cmp);
        StudentInfoTool.write2File(stus);
    }
}