05java基础

1.BigInteger和BigDecimal类

package cn.jxufe.java.chapter5.demo01;

import java.math.BigInteger;

public class TestBigInterger {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BigInteger a = new BigInteger("9223372036854775807");
        BigInteger b = new BigInteger("2");
        BigInteger c = a.multiply(b);
        System.out.println(c);
    }

}

package cn.jxufe.java.chapter5.demo01;

import java.math.BigDecimal;
import java.math.BigInteger;

public class TestBigInterger {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
、
        BigDecimal e = new BigDecimal(1.0);
        BigDecimal f = new BigDecimal(3);
        BigDecimal g = e.divide(f, 20, BigDecimal.ROUND_UP);
        System.out.println(g);

    }

}

2.Object类

Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。

2.1equals方法

equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是==比较运算符。

在开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较，也就是在开发经常需要子类重写equals方法根据对象的属性值进行比较。如下代码演示：

package cn.jxufe.java.chapter5.demo01;

public class EqualsClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(p1.equals(p2));
        p1.age = 10;
        p2.age = 100;
        System.out.println(p1.equals(p2));
    }

}

/*
 * 描述人这个类，并定义功能根据年龄判断是否是同龄人 由于要根据指定类的属性进行比较，这时只要覆盖Object中的equals方法
 * 在方法体中根据类的属性值进行比较
 */
class Person extends Object {
    int age;

//复写父类的equals方法，实现自己的比较方式
    public boolean equals(Object obj) {
        // 判断当前调用equals方法的对象和传递进来的对象是否是同一个
        if (this == obj) {
            return true;
        }
        // 判断传递进来的对象是否是Person类型
        if (!(obj instanceof Person)) {
            return false;
        }
        // 将obj向下转型为Perosn引用，访问其属性
        Person p = (Person) obj;
        return this.age == p.age;
    }
}

2.2toString方法

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

package cn.jxufe.java.chapter5.demo01;

public class ToString {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person2 p1 = new Person2();
        System.out.println(p1.toString());
    }

}

class Person2 extends Object {
    int age;

    // 根据Person类的属性重写toString方法
    public String toString() {
        return "Person [age=" + age + "]";
    }
}

3.String类

3.1不可变字符串

查阅API中的String类的描述，发现String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

//演示字符串
String str  = "itcast";
str = "山水集团";

继续查阅API发现说字符串是常量；它们的值在创建之后不能更改，这是什么意思呢？其实就是说一旦这个字符串确定了，那么就会在内存区域中就生成了这个字符串。字符串本身不能改变，但str变量中记录的地址值是可以改变的。

继续查API发现，字符串有大量的重载的构造方法。通过String类的构造方法可以完成字符串对象的创建，那么，通过使用双引号的方式创建对象与new的方式创建对象，有什么不同呢？看如下程序与图解：

package cn.jxufe.java.chapter5.demo01;

public class StringClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s1.equals(s3));// 因为String重写了equals方法，建立了字符串自己的判断相同的依据（通过字符串对象中的字符来判断）
    }

}

s2和s3的创建方式有什么不同呢？

• s2创建，在内存中只有一个对象。这个对象在字符串常量池中
• s3创建，在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中

3.2字符串的替换和分隔

package cn.jxufe.java.chapter5.demo01;

public class TestString1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s = "Welcome";
        String t = s.replace('e', 'A');
        System.out.println(s);
        System.out.println(t);
        String t2 = s.replaceFirst("e", "A"); // 注意为双引号
        System.out.println(t2);
        String t3 = s.replaceAll("e", "A"); // 注意为双引号
        System.out.println(t3);

    }
}

package cn.jxufe.java.chapter5.demo01;

public class TestString2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] token = "Java#Html#Python".split("#");// 注意是双引号
        for (String e : token) {
            System.out.println(e);
        }
    }

}

3.3依照模式匹配、替换和分隔

public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("java".matches("java"));
        System.out.println("java".equals("java"));
    }

public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.out.println("java is fun".matches("java.*"));
        System.out.println("java is cool".matches("java.*"));

    }

更多的正则表达式用法，将在后面进行总结。

3.4字符串和数组直接的转换

package cn.jxufe.java.chapter5.demo01;

import java.util.Arrays;

public class TestString4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        char[] chars = "javaAndPython".toCharArray();
        System.out.println(Arrays.toString(chars));
        char[] dst = { 'a', 'b', 'c', 'd', 'e', 'f' };
        "javaAndPython".getChars(2, 4, dst, 0);
        System.out.println(Arrays.toString(dst));
    }

}

package cn.jxufe.java.chapter5.demo01;

public class TestString5 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String string = new String(new char[] { 'j', 'a', 'v', 'a' });
        System.out.println(string);

        String string2 = String.valueOf(new char[] { 'j', 'a', 'v', 'a' });
        System.out.println(string2);
    }

}

3.5格式化字符串

• 搭配转换符的标志

以对齐的方式打印二维数组

package cn.jxufe.java.chapter5.demo01;

public class FormateString {

    public static void main(String[] args) {
        double[][] array = { { 125.66667, 35.2, 48.6666547 }, { 123456.2, 23.1, -0.25678 } };
        String s1 = String.format("%10.3f", array[0][0]);
        String s2 = String.format("%10.3f", array[0][1]);
        String s3 = String.format("%10.3f", array[0][2]);
        String s4 = String.format("%10.3f", array[1][0]);
        String s5 = String.format("%10.3f", array[1][1]);
        String s6 = String.format("%10.3f", array[1][2]);

        System.out.println(s1 + s2 + s3);
        System.out.println(s4 + s5 + s6);
    }

}

4.StringBuilder和StringBuffer类

4.1修改StringBuilder中的字符串

package cn.jxufe.java.chapter5.demo01;

public class TestStringBuilder {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Welcome");
        stringBuilder.append(' ');
        stringBuilder.append("to");
        stringBuilder.append(' ');
        stringBuilder.append("java");
        System.out.println(stringBuilder);

        stringBuilder.insert(11, "html and ");
        System.out.println(stringBuilder);
        stringBuilder.insert(11, 110); // 重载了,支持int型，同理追加的那些类型，插入也都支持
        System.out.println(stringBuilder);

        stringBuilder.delete(11, 14);
        System.out.println(stringBuilder);

        System.out.println(stringBuilder.reverse());
        System.out.println(stringBuilder.reverse());// 翻转

        System.out.println(stringBuilder.replace(11, 15, "good"));// 替换
    }

}

5.示例学习：判断回文串

package cn.jxufe.java.chapter5.demo01;

import java.util.Scanner;

/**
 * 判断回文串
 *
 * @author Administrator
 *
 */
public class Example {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        System.out.println("enter a string ");
        String string = input.nextLine();
        System.out.println("Ignore nonalphanumeric characters is " + string + " a palindrome? " + isPalindrome(string));
    }

    public static boolean isPalindrome(String s) {
        String s1 = fliter(s);
        String s2 = reverse(s1);

        return s1.equals(s2);
    }

    public static String fliter(String s) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (Character.isLetterOrDigit(s.charAt(i))) {
                stringBuilder.append(s.charAt(i));
            }
        }
        return stringBuilder.toString();
    }

    public static String reverse(String s) {
        StringBuilder stringBuilder = new StringBuilder(s);
        stringBuilder.reverse();
        return stringBuilder.toString();
    }

}

6.包装类

6.1为什么需要包装类

在实际程序使用中，程序界面上（注意不是在控制台）用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等。那么，想实现字符串与基本数据之间转换怎么办呢？

6.2包装类的作用

最常用的作用：用于在基本数据和字符串之间进行转换。

6.3包装类和基本数据类型的对应关系

6.4包装类对象的创建方式

6.5包装类的常用方法

package cn.jxufe.java.chapter5.demo02;

/**
 * 测试包装类
 * Integer类的使用。其他包装类用法类似，课下自己学。
 *
 */
public class TestWrappedClass {
    public static void main(String[] args) {
        //基本数据类型转成包装类对象
        Integer   a  = new  Integer(3);
        Integer   b  = Integer.valueOf(30);   

        //把包装类对象转成基本数据类型
        int   c  =  b.intValue();
        double d = b.doubleValue();

        //把字符串转成包装类对象
        Integer  e = new  Integer("9999");
        Integer  f = Integer.parseInt("999888");

        //把包装类对象转成字符串
        String   str = Integer.toString(110);    

        //常见的常量

        System.out.println("int类型最大的整数："+Integer.MAX_VALUE);
        System.out.println(str);
        System.out.println(Integer.parseInt("123"));
    }
}

6.6自动装箱和自动拆箱

把基本的数据类型转换成相应的包装类型的对象称为装箱；

把包装类型对象转换为相应的基本数据类型称为拆箱。

JDK5.0之后提供了自动装箱和拆箱的功能。

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; 加法运算完成后，再次装箱，把基本数值转成对象。

自动装箱(byte常量池)细节的演示

当数值在byte范围之内时，进行自动装箱，不会新创建对象空间而是使用医来已有的空间。

package cn.jxufe.java.chapter5.demo02;

public class TestInteger {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer a = new Integer(3);
        Integer b = new Integer(3);
        System.out.println(a==b);//false
        System.out.println(a.equals(b));//true

        Integer c = 3; //自动装箱了
        Integer d = 3;
        System.out.println(a==b);//false
        System.out.println(a.equals(b));//true

        System.out.println("---------------------");
        Integer x = 127;
        Integer y = 127;
        //在jdk1.5自动装箱时，如果数值在byte范围之内，不会新创建对象空间而是使用原来已有的空间。
        System.out.println(x==y); //true
        System.out.println(x.equals(y)); //true

    }

}

7.时间处理相关类

7.1System.currentTimeMillis()

我们把1970 年 1 月 1 日 00:00:00定为基准时间,现在时刻的“时刻数值”，可以使用：

System.out.println(System.currentTimeMillis());

7.2Date类

package cn.jxufe.java.chapter5.demo02;

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

public class TestTime {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(System.currentTimeMillis());
        Date date = new Date();
        Date date2 = new Date(2000);// 2000毫秒
        System.out.println(date2);

        System.out.println(date);
        System.out.println(date.getTime());
        System.out.println(date.after(date2));// 测试此日期是否在指定日期之后。
        System.out.println(date.before(date2));// 测试此日期是否在指定日期之前。
        System.out.println(date.toString());
        /*
         * 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天
         * (Sun、 Mon、Tue、
         */

        SimpleDateFormat f = new SimpleDateFormat("yyyy-MMMM-dd-E");
        SimpleDateFormat g = new SimpleDateFormat("yyyy-MM-dd-EEEE");
        SimpleDateFormat w = new SimpleDateFormat("yyyy/MM/dd");
        System.out.println(f.format(date));
        System.out.println(g.format(date));
        System.out.println(w.format(date));

        SimpleDateFormat s1 = new SimpleDateFormat("D");//D表示年中的天数
        String daytime = s1.format(new Date());
        System.out.println(daytime);
    }

}

7.3Calendar类

package cn.jxufe.java.chapter5.demo02;

import java.util.Calendar;

public class TestCalendar {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Calendar now = Calendar.getInstance();
        int year = now.get(Calendar.YEAR);
        System.out.println(year);
        int Month = now.get(Calendar.DAY_OF_MONTH);
        System.out.println(Month);
        int month = now.get(Calendar.MONTH)+1; // 0是1月，1是2月，从0开始
        System.out.println(month);
        int week = now.get(Calendar.DAY_OF_WEEK)-1;//周日是第一天，周一是第二天
        System.out.println(week);
    }

}