常用类

包装类(Wrapper)

装箱：包装类使得一个基本数据类型的数据变成了类。
拆箱：将数字包装类中内容变为基本数据类型。
有了类的特点，可以调用类中的方法。
对于8中基本类型，都有其相应的包装类，int—->Integer
char —–>Character
这样就可以调用包装类中的方法。
其余的都是基本数据类型，首字母大写。

在JDK1.5以后，支持自动装箱，自动拆箱。
有关自动装箱，自动拆箱，手工装箱/拆箱的程序：
1.利用构造器手工装箱，.xxxValue()方法手工拆箱
2.自动拆箱，自动装箱，直接进行赋值就好，将Integer当做int用
3.字符串—>基本数据类型
调用包装类的parseXxx(String s)静态方法
4.基本数据类型—>字符串类型
调用字符串重载的valueOf()方法
或者直接 + “”

import org.junit.Test;

public class WrapperTest {

    @Test
    public void exer1() {
        // 声明两个字符串, 其中的内容是两个整数, 把第一个先转成基本数据类型,再装箱 , 第二个直接装箱 
        // 分别使用手工拆箱求和, 自动拆箱求积, 并打印输出
        String string1 = "300";
        String string2 = "50";
        int num1 = Integer.parseInt(string1);
        Integer obj1 = new Integer(num1);
        Integer obj2 = Integer.decode(string2);
        System.out.println(obj1.intValue() + obj2.intValue());
        System.out.println(obj1 * obj2);
    }


    @Test
    public void test1() {
        Integer obj1 = new Integer(100); // 手工装箱
        Integer obj2 = 200; // 自动装箱  new Integer(200);
        System.out.println(obj1);
        System.out.println(obj2);

        Object obj = 300; // Object obj = new Integer(300);

        int num1 = obj1.intValue(); // 手工拆箱
        int num2 = obj2; // 自动拆箱
        System.out.println(num1 * num2);
        System.out.println(obj1 * obj2);

        // 手工装箱 
        boolean b1 = true;
        Boolean obj3 = new Boolean(b1);
        // 手工拆箱
        boolean b2 = obj3.booleanValue();

        Double obj4 = 3.14;
        obj4 = obj4 * 20; // obj4 = new Double(obj4.doubleValue() * 20);
        System.out.println(obj4);

        String string = "2343";
        int value = Integer.parseInt(string);
        System.out.println(value);
        string = "false";
        boolean b3 = Boolean.parseBoolean(string);
        System.out.println(b3);
        string = ".334";
        double d1 = Double.parseDouble(string);
        System.out.println(d1);

    }
}

String类：
常量对象：字符串常量对象是用双引号括起的字符序列。
如：”hello”
字符串的字符使用Unicode字符编码，一个字符占两个字节。
对于使用常量对象和new给字符串引用赋值，不同，常量对象是在常量区开辟一块空间保存常量对象，new是在GC区开辟一块空间保存String型对象。
分析代码：

@Test 
    public void Test1() {
        //对于字符串，核心：有new便是在GC区开辟空间存储，字符串拼接，隐含new
        //但是对于字符串拼接，若是多个字符串常量拼接，因为经过优化，所以同样是在常量区存储，
        //若是赋值号右边为字面值（字符串常量），则是在常量区存储
        /*
         * str1和str2指向常量区的同一块内存（该内存保存"atguigu"）
         */
        String str1 = "atguigu";
        String str2 = "atguigu";
        System.out.println(str1 == str2);   //true
        System.out.println("------------------");
        //在GC区中开辟一块空间保存"atguigu",并将地址写入str3
        //str3和str1(str2)指向不同
        String str3 = new String("atguigu");
        System.out.println(str1 == str3);   //false
        System.out.println("------------------");
        //此程序，现在GC区中开辟一块空间，保存str1,str2连接的新串，将地址写入str4
        str2 = "java";
        String str4 = str1 + str2;
        System.out.println(str4);
        //常量区开辟一块空间，保存"atguigujava"，将地址写入str5
        String str5 = "atguigujava";
        System.out.println(str4 == str5);   //false
        //此代码是两个常量值相加，编译器优化，先在常量区找看有没有"atguigujava",没有的话创建，有的话直接将地址写入
        System.out.println("-------------------");
        String str6 = "atguigu" + "java";
        System.out.println(str5 == str6);   //true
        System.out.println("-------------------");
        //若是将 str4 = str1 + str2改为 (str1 + str2).intern 
        //intern方法将字符串写到常量区，若是有写，没有创建
        //str4 =(str1 + str2).intern();
        str4 = str4.intern();
        System.out.println(str4 == str5);   //true
    }

String是一个final类，代表不可变的字符序列。

String类常用方法：

import org.junit.Test;

/** 字符串 : 
 *      是内容不可改变的Unicode字符序列
 * 
 *  任何对于字符串内容的改变都将会产生新的字符串对象
 * 
 *   0123456789 11 14  17    21  25 
 *  "  abcXXXyyyZZZ你好吗?我不好qqq  "
 *  public int length() // 26
    public char charAt(int index) // 获取指定下标处的字符
    public char[] toCharArray() // 把字符串转换为真的字符数组
    public boolean equals(Object anObject)
    public int compareTo(String anotherString)
    public int indexOf(String s) // 判断参数中的子串在本字符串中首次出现的下标 indexOf("qqq"):21, indexOf("好"):15, indexOf("坏"):-1
    public int indexOf(String s ,int startpoint) //indexOf("qqq", 10):21, indexOf("好", 18):20
    public int lastIndexOf(String s) // lastIndexOf("qqq"):21, lastIndexOf("好"):20
    public int lastIndexOf(String s ,int startpoint) // lastIndexOf("qqq", 5):-1, lastIndex("好", 17):15
    public boolean startsWith(String prefix)//判断当前串是否是以参数中的子串为开始 statsWith("abc"):false, startsWith("  a"):true
    public boolean endsWith(String suffix)
    public String substring(int start,int end)//截取子串包含开始索引,不包含结束索引,获取子串,[start,end)
    public String substring(int startpoint)
    public String replace(char oldChar,char newChar) // 替换字符串中的全部老字符为新字符
    public String replaceAll(String old,String new)
    public String trim() // 去除字符串首尾的空白字符
    public String concat(String str) // 连接当前串和参数中的串
    public String[] split(String regex) // 把字符串以参数中的子串为切割器, 切割成若干部分 split("好");

 */
public class StringTest {

    @Test
    public void exer7() {
        String string3 = "张三,30,80;李四,40,70;王五,50,90;赵六,60,100";
        String[] arr = string3.split(";");
        Person[] persons = new Person[arr.length];
        for (int i = 0; i < arr.length; i++) {
            String[] arr2 = arr[i].split(",");
            persons[i] = new Person(arr2[0], Integer.parseInt(arr2[1]), Integer.parseInt(arr2[2]));
        }
        for (Person person : persons) {
            System.out.println(person);
        }
    }

    @Test 
    public void test6() {
        String string = "100,200,300,400,500,600";
        String[] arr = string.split(",");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        String string2 = "张三,30,80";
        String[] arr2 = string2.split(",");
        Person person = new Person(arr2[0], Integer.parseInt(arr2[1]), Integer.parseInt(arr2[2]));
        System.out.println(person);
    }

    //模拟一个trim方法，去除字符串两端的空白字符。
    @Test
    public void exer4() {
        String string = "                                  ";
        int begin = -1;
        int end = string.length() - 1;
        for (int i = 0; i < string.length(); i++) {
            if (string.charAt(i) > 32) {
                begin = i;
                break;
            }
        }
        for (int i = string.length() - 1; i >= 0; i--) {
            if (string.charAt(i) > 32) {
                end = i;
                break;
            }
        }
        if (begin == -1) {
            System.out.println("");
        } else {
            String result = string.substring(begin, end + 1);
            System.out.println(result);
        }
    }

    @Test 
    public void test5() {
        String string = "  \n   \t\t   abcXXXyyyZZZ你好吗?我不好qqq           \t\r\n";
        System.out.println(string.substring(10, 21));
        // 截取从Z开始到末尾
        System.out.println(string.substring(11, string.length())); 
        System.out.println(string.substring(11)); // 和上面的效果一样
        String newStr = string.replace(' ', '*');
        System.out.println(newStr);
        String newStr2 = string.replaceAll("好", "坏");
        System.out.println(newStr2);
        String newStr3 = string.trim();
        System.out.println(newStr3);
        String newStr4 = newStr3.concat("100");
        System.out.println(newStr4);
    }

    @Test // 反例
    public void test4() {
        String string = "abc";
        for (int i = 0; i < 10000000; i++) {
            string += i;
        }
        System.out.println(string);
    }

    /**
     * 求短串在长串中出现的次数
     * @param string1
     * @param string2
     * @return
     */
    public int getCountOfSubstring(String string1, 
    String string2) {
        if (string2.length() > string1.length()) {
            String tmp = string1;
            string1 = string2;
            string2 = tmp;
        }
        int count = 0;
        int index = 0;
        while (true) {
            // 去尝试查找子串
            index = string1.indexOf(string2, index);
            if (index == -1) {
                break;
            }
            count++;
            index++;
        }
        return count;
    }

    @Test
    public void exer3() {
        /*获取一个字符串在另一个字符串中出现的次数。
           比如：获取"ab"在 "abkkcadkabkebfkabkskab"    
          中出现的次数*/
        String string1 = "aaaaa";
        String string2 = "aa";
        int count = getCountOfSubstring(string2, string1);
        System.out.println(count);
    }

    @Test
    public void test3() {
        //String(char[] value, int offset, int count) 
        char[] arr = {'a','b','你','他','嘿','来'};
        String string = new String(arr);
        System.out.println(string);
        String string2 = new String(arr, 2, 3); // 2是开始下标,3是总共的字符数
        System.out.println(string2);
        String string3 = new String("abcccc");
        System.out.println(string3);
        String string4 = new String(arr, 0, arr.length);
        System.out.println(string4);


    }

    @Test
    public void test2() {
        String string = "  abcXXXyyyZZZ你好吗?我不好qqq  ";
        System.out.println(string.length());
        System.out.println(string.charAt(18));
        System.out.println("--------------------");
        for (int i = 0; i < string.length(); i++) {
            char ch = string.charAt(i);
            System.out.println(ch);
        }
        // 把字符串变成全部大写的
    }

    @Test
    public void exer2() {
        // 把字符串反转成新的字符串
        String string = "  abcXXXyyyZZZ你好吗?我不好qqq  ";
        String newStr = "";
        for (int i = string.length() - 1; i >= 0; i--) {
            newStr += string.charAt(i);
        }
        System.out.println(newStr);
    }

    @Test
    public void exer22() {
        // 把字符串反转成新的字符串
        String string = "  abcXXXyyyZZZ你好吗?我不好qqq  ";
        String newStr = "";
        for (int i = 0; i < string.length(); i++) {
            newStr = string.charAt(i) + newStr;
        }
        System.out.println(newStr);
    }
    /*
        toCharArray() 将字符串转化成字符数组
    */
    @Test
    public void exer23() {
        // 把字符串反转成新的字符串
        String string = "  abcXXXyyyZZZ你好吗?我不好qqq  ";
        char[] arr = string.toCharArray();
        for (int i = 0; i < arr.length / 2; i++) {
            char tmp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = tmp;
        }
        String newStr = new String(arr);
        System.out.println(newStr);
    }
    /*
        要知道字符串是一个不可变得序列，对字符串进行任何操作都要造新串，拼接
    */
    @Test
    public void exer1() {
        // 把字符串变成全部大写的
        String string = "  abcXXXyyyZZZ你好吗?我不好qqq  ";
        String newStr = "";
        for (int i = 0; i < string.length(); i++) {
            char ch = string.charAt(i);
            if (ch >= 'a' && ch <= 'z') {
                // 变成大写
                ch -= 32;
            }
            newStr += ch;
        }
        System.out.println(newStr);
    }

    @Test
    public void test1() {
        String string = "abc";
        string += 100; // string = string + 100;
        System.out.println(string);
    }
}

public class Person {

    private String name;
    private int age;
    private double weight;

    public Person() {
    }

    public Person(String name, int age, double weight) {
        super();
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    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;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", weight=" + weight
                + "]";
    }

}

StringBuffer：是内容可以改变的Unicode字符序列
StringBuffer类有三个构造方法：
1．StringBuffer()初始容量为16的字符串缓冲区
2．StringBuffer(int size)构造指定容量的字符串缓冲区
3．StringBuffer(String str)将内容初始化为指定字符串内容

import org.junit.Test;

/**
 * StringBuffer :
 *      是内容可以改变的Unicode字符序列 
 * append(...) 追加内容到末尾 
 * insert(int index, ...); 在指定位置处插入新内容 
 * delete(int begin, int end); 删除子串 
 * setCharAt(int index, char newCh); 替换指定位置处的字符为newCh
 *
 */
public class StringBufferTest {

    @Test
    public void test2() {
        String text = "";
        long startTime = 0L;
        long endTime = 0L;
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));
        // 声明3个字符串, 以第1个为参数创建StringBuilder,把第二个串追加在后面,把第三个插入到最前面, 打印输出
    }

    @Test
    public void test1() {
        StringBuffer sBuffer = new StringBuffer("原始字符串");
        sBuffer.append(100).append(false).append(3.14).append("新串");
        sBuffer.append(new Person());
        System.out.println(sBuffer);

        sBuffer.insert(2, "部落");
        sBuffer.insert(2, 100.23f);

        System.out.println(sBuffer);

        sBuffer.delete(2, 7); // 删除字符串指定部分

        System.out.println(sBuffer);
    }
}

StringBuilder类：
同样是可变的字符序列。
对比：
StringBuffer：可变字符序列、效率低、线程安全
StringBuilder(JDK1.5)：可变字符序列、效率高、线程不安全
其余StringBuilder与StringBuffer方法类似

@Test
    public void Exer() {
        String string = "abc";
        String string2 = "lg123";
        String string3 = "w2345";
        //创建一个StringBuilder对象
        StringBuilder sBuilder = new StringBuilder(string);
        //在它后边拼接字符串
        sBuilder.append(string2);
        //在指定位置插入字符串
        sBuilder.insert(0, string3);
        System.out.println(sBuilder);
    }

Date类

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

import org.junit.Test;

public class OtherTest {

    @Test
    public void testDate2() {
        //Calendar calendar = new Calendar();
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);
        //calendar.getYear();
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
        System.out.println(hour);

        calendar.set(Calendar.YEAR, 1996);
        calendar.set(Calendar.MONTH, 4); // 比实际值小1
        calendar.set(Calendar.DAY_OF_MONTH, 15);

        System.out.println(calendar.getTime());
    }

    @Test
    public void testDate() throws ParseException {
        Date date = new Date();
        System.out.println(date);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = sdf.format(date);
        System.out.println(dateString);

        String string2 = sdf.format(System.currentTimeMillis());
        System.out.println(string2);

        String string3 = "2999-05-20 22:10:30"; // 字符串的格式满足格式化器
        Date date2 = sdf.parse(string3); // 字符串->对象
        System.out.println(date2);

        System.out.println(date.after(date2));
        date2.setTime(System.currentTimeMillis()); // 设置时间
        System.out.println(date2);
        long time = date2.getTime();
    }

    @Test
    public void testSystem() {
        long time1 = System.currentTimeMillis();
        System.out.println(time1);

        System.gc(); // 建议运行垃圾回收

        try {
            System.exit(0); // 正常退出, 中止虚拟机
            //return;
        } finally {
            System.out.println("finally...");
        }
        //System.out.println("after exit...");
    }
}

一个时钟小程序：

import java.util.Date;
import java.text.SimpleDateFormat;
/**
    简易时钟
*/
public class Clock {

    public static void main(String[] args) {
        //创建一个格式化对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        while(true) {
            //调用format方法
            String str = sdf.format(System.currentTimeMillis());
            //刷新时间，\r作用是会在一行的行首，对以前的数据进行覆盖
            System.out.print("\r" + str);
        }

    }
}