java常用类-上

一，常用类之一包装类

java开发中习惯把八大基本数据类型封装到一个类中，并提供属性和方法，更方便的操作基本数据类型。

包装类的出现并不是用于取代基本数据类型，也取代不了。

包装类位于java.lang包中。

Number 类

Number数值类型是byte、double、float、int、long 和 short类的抽象父类，提供把包装类转化成基本数据类型的方法(xxxValue)

下面就用Integer来举例

Interger 是int基本数据类型的包装类，在Integer内部封装了一个final int value的属性

integer的常用方法：

（1）构造方法：

public static void main(String[] args) {
        // 【2】构造方法
        int a = 10;
        String bStr = "20";
        Integer i1 = new Integer(a);
        // 可能抛出NumberFormatException异常，毕竟String类型值不都是int类型
        Integer i2 = new Integer(bStr);
        System.out.println(i1.toString());
        System.out.println(i2.toString());
    }

（2）int<->Integer<->string 三者之间的相互转换

public static void main(String[] args) {
   //int->integer
      Integer i1=new Integer(10);
      Integer i2=Integer.valueof(20);
  //Integer->int
      int a=i1.intValue();
   // String->Integer(和int转integer形式差不多)
        Integer i3=new Integer("30");
        Integer i4=Integer.valueOf("40");
//Integer->String
System.out.print(i3.toString());
// String->int
int b=Integer.parseInt("50");
// int->String
        String c=Integer.toString(60);
}

（3）Comparable接口

Comparable 表示具有比较能力，对象可比较大小，此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

Comparable 定义了a.compareTo(b),返回值表示

a.compareTo(b)	返回值	排序
a < b	负整数	升序
a = b	0	相等
a > b	正整数	降序

自动装箱和自动拆箱

自动装箱：把基本数据类型自动转化成对象的包装类的过程称为自动装箱(auto-boxing)

形式：Integer i=10；

自动拆箱：把包装类自动转化成对于的基本数据类型的过程称为自动拆箱(auto-unboxing)

形式：int a=i；

public static void main(String[] args) {
     //自动装箱
     Integer b=10;//省略了b=new Integer(10);
        System.out.print(b.toString());
 //自动拆箱
     Integer a=new Integer(10);
     int c=a; //省略了 c=a.intvalue();
    }

注意：不要过于频繁使用拆装箱操作

另外拆装箱特性出自jdk1.5版本。

Integer包装类举例就到这里，举一反三其它基本数据类型包装类也和这个是一个形式的。

二，常用类之二 String

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的对象。

字符串本质上是一个字符数组，它们的值在创建之后不能更改，所以字符串是常量；

可以把字符串看出是字符数组的包装类，内部声明一个private final char value[];

因为 String 对象是不可变的，所以可以共享（通过字面量创建的String分配在常量区）

字符串常用方法：

（1）构造方法

public static void main(String[] args) {
               String str1 = new String();

        // 通过一个字节数组构建一个字符串
        byte[] bytes = {97,98,99};
        // 通过使用平台的默认字符集解码指定的 byte 数组
        // System.out.println(Charset.defaultCharset());  这个是查看自己电脑系统的编码类型的
        String str2 = new String(bytes);
        System.out.println(str2);

// 当然也可以使用指定的字符集对字节序列进行解码
byte[] byte2 = {-42,-48};
        String str3 = null;
        try {
            str3 = new String(byte2,"GBK");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println(str3);

// 通过字符数组构建字符串
        char[] c1 = {'a','b','c','中','国'};
        String str5 = new String(c1); //拼接c1中所有的元素成为一个字符串
        String str5 = new String(c1,0,3);  //选择c1中从0位到第2位元素拼接成一个字符串
        System.out.println(str5);
    }

（2）字符串的比较

public static void main(String[] args) {
        // 【3】字符串比较 （比较结果上面参考上面的compareto方法）
                String str1 = "abc";
                String str2 = "Abc";

                System.out.println(str1.compareTo(str2));
                // 忽略大小写比较
                System.out.println(str1.compareToIgnoreCase(str2));
    }

（3）查找，搜索字符串

public static void main(String[] args) {
        // 【3】查找、搜索字符串中是否包含其他子串
                String str1 = "hello world";

                // 是否包含子串"world"
                System.out.println(str1.contains("world"));
                //是否从子串"he"开始的
                System.out.println(str1.startsWith("he"));
                //是否以子串"world"结束的
                System.out.println(str1.endsWith("world"));
                //位置2上开始的子串是不是"ll"
                System.out.println(str1.startsWith("ll", 2));
    }

总结：不同的后缀方法实现不同的项目需求（方法较多，可查看jdk）

（4）格式化字符串

通过指定占位符(%开始)格式化字符串

%d	格式化整形
%f	格式化浮点型
%.nf	格式化浮点型四舍五入保留n为小数，
%c	格式化字符
%s	格式化字符串

举一个例子：

public static void main(String[] args) {
        // 【4】格式化字符串
        float price = 998.126f;
        int a  = 10;
        int b = 2;
        // 10 / 2 = 5

        String str1 = String.format("%d / %d = %d", a,b,(a/b));//注意这个.format，因为我经常容易忘记
        System.out.println(str1);
        // 四舍五入保留两位小数
        String str2  =String.format("$%.2f", price);
        System.out.println(str2);
    }

（5）替换字符串（主要是考察replace）

其余没啥特别的

public static void main(String[] args) {
        String str1 = "hello,world";
        String newStr1 = str1.replace('o', '8');
        System.out.println(newStr1);

        String newStr2 = str1.replace("ll", "");
        System.out.println(newStr2);

    }

（6）拆分字符串（spilt）

public static void main(String[] args) {

            //【7】 根据指定字符串拆分字符串
            String str1 = "abc-123";
            String[] arr = str1.split("-");
            System.out.println(Arrays.toString(arr));

            // 需求:请快速构建一个26个小写英文字母的数组
            String str2= "abcdefghijklmnopqrstuvwxyz";
            String[] arr2 = str2.split("");
            System.out.println(Arrays.toString(arr2));
}

（7）子串大小写互换

public static void main(String[] args)  {

        //【8】 求子串
        String str1 = "abc123";
        // fromIndex:开始位置，endInde 结束的位置
        // 含头不含尾
        String sub1 = str1.substring(0, 3);
        System.out.println(sub1);

        String sub2 = str1.substring(3);
        System.out.println(sub2);

        // 【9】大小写转换
        String str3 = "Abc";
        System.out.println(str3.toUpperCase());
        System.out.println(str3.toLowerCase());

    }

（8）其它方法

public static void main(String[] args)  {

        // 去掉前导空格和后导空格 ，注意字符串长度没改变
        String str1 = "  abc   ";
        String newStr1 = str1.trim();
        System.out.println(str1.length());

        // 获取字符串的字符数组
        char[] arr = str1.toCharArray();
        System.out.println(Arrays.toString(arr));

        // 把其他数据类型转化为字符串
        String str2 = String.valueOf(10);
        System.out.println(str2);
    }

 三，StringBuffer

StringBuffer是字符的可变容器。可以在程序运行过程中向容器中添加、删除、修改字符。

StringBuffer 本质上是一个字符数组的包装类，并提供了很多方法向这个字符数组中添加、删除、修改字符。

StringBuffer 是线程安全的（区别于StringBuilder）

工作原理：

StringBuffer 内部维护了一个字符数组，默认字符数组的长度是16.当开发者向这个字符数组中添加元素时，如果有额外空间，直接添加到数组中，如果没有额外空间，StringBuffer内部自动拓容，拓容规则:当前容量*2+2,根据拓容的新空间，复制当前的数组内容到新数组中

public static void main(String[] args) {

        StringBuffer sb = new StringBuffer();
        sb.append("a");
        sb.append("b");
        System.out.println(sb.capacity());

        sb.append("1234567890ABCD");
        sb.append('x');
        System.out.println(sb);
        System.out.println(sb.capacity());

        // 未来如果确定不再向sb中添加字符，
        // 优化内部的数组到指定的长度
        sb.trimToSize();
        System.out.println(sb.capacity());
    }

输出结果：

stringbuffer的常用方法：

public static void main(String[] args) {

        StringBuffer sb1 = new StringBuffer();
        // 【1】添加
        sb1.append("hello");
        sb1.append('d');

        // 返回字符串的长度
        System.out.println(sb1.length());
        // 返回容器的大小
        System.out.println(sb1.capacity());

        // 【2】删除
        //System.out.println(sb1);
        //sb1.delete(0, 5);
        //System.out.println(sb1);

        // 【3】insert(index,t) 在指定位置index添加t
        sb1.insert(0, "123");
        System.out.println(sb1);

        // 【4】修改
        sb1.setCharAt(0, 'A');
        System.out.println(sb1);

        // 【5】setLength
        sb1.setLength(0); // 清空容器内容
        sb1.append("中国");
        System.out.println(sb1);
    }

总结就是增删改查。。。

对比下stringbuilder：

StringBuffer 是线程安全的，执行效率低，JDK1.0就有

StringBuilder 就是为了缓解执行效率低而产生的，但线程不安全。JDK 1.5才有。