java 常用类

1.1 包装类

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

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

 　　包装类位于java.lang包中。

 　　Number 类

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

1.1 Integer

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

1.1.1 常用方法

 [1] 构造方法

public static void main(String[] args) {
        // 【1】Integer 属性(int的最大值和最小值)
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        
        // 【2】构造方法  integer 不仅可以包装int类型的数值，也可以包装string类型的数值
        int a=10;
        Integer i1=new Integer(a);
        System.out.println(i1.toString());
        
        String str="20";
        Integer i2=new Integer(str);
        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
        Integer i3 = new Integer("30");
        Integer i4 = Integer.valueOf("40");
        
        //Integer->String
        System.out.println(i3.toString());
        
        
        // String->int
        int b = Integer.parseInt("50");
        
        // int->String
        String str = Integer.toString(10);
        //String str2 = Integer.toString(8, 2);
        //System.out.println(str2);
    }

[3] Comparable接口

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

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

a.compareTo(b)                              返回值                                         排序

a<b                                                  负整数                                          升序

a=b                                                       0                                             相等

a>b                                                   正整数                                        降序

 

// 【2】Integer的比较
        Integer i5= new Integer(20);
        Integer i6=new Integer(30);
        System.out.println(i5.equals(i6));
        System.out.println(i5.compareTo(i6));

//equals  比较时，输出值是false或者ture
//compareTo  比较时，输出值是0，，1，，，-1 的数值

 

 

1.2.2自动装箱和自动拆箱

 

自动装箱

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

Integer i = 10;

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

int a = i;

public static void main(String[] args) {
        
        // Integer i1 = new Integer(10);
        // 自动装箱
        Integer i2 = 20; // i2 = new Integer(20);
        System.out.println(i2.toString());
        
        // 自动拆箱
        Integer i3 = new Integer(30);
        int a = i3; // i3.intValue();
    }

注意:

[1]自动装箱和自动拆箱是jdk1.5

[2]不要过于频繁的使用拆装箱操作

1.3String

 

1.3.1 字符串本质

 

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

 

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

 

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

 

 因为 String 对象是不可变的，所以可以共享。

 

通过字面量创建的字符串分配在常量区。 比如：int  a=10;就分配在常量区，string a="20";就分配在堆区

1.3.2 字符串常用方法

[1]构造方法

import java.io.UnsupportedEncodingException;

public class Test03 {
public static void main(String[] args) {
    // 在堆区初始化一个空字符串
    String str=new String();
    // 通过一个字节数组构建一个字符串
    byte[] byts={97,98,99};
    // 通过使用平台的默认字符集解码指定的 byte 数组
    // System.out.println(Charset.defaultCharset());
    String str2=new String(byts);
    System.out.println(str2);
    
    
    byte[] byte2={-42,-48};
    String str3=null;
    System.out.println(str3);
    // 需求:对一个utf-8的字节序列进行解码
    byte[] byte3={-28,-72,-83,-28,-72,-83};
    try {
        // sssString str4 = new String(byte3, "UTF-8");
        String str4 = new String(byte3,0,3, "UTF-8");
        System.out.println("str4:"+str4);
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    // 通过字符数组构建字符串
            char[] c1 = {'a','b','c','中','国'};
            // String str5 = new String(c1);
            String str5 = new String(c1,0,3);
            System.out.println(str5);
}
}

[2] 字符串的比较

public static void main(String[] args) {
        // 【3】字符串比较
        String str1 = "abc";
        String str2 = "Abc";
        
        System.out.println(str1.compareTo(str2));
        // 忽略大小写比较
        System.out.println(str1.compareToIgnoreCase(str2));
        
        // 需求:请输入验证码
        /*String validCode = "a4Df";
        System.out.println("请输入验证码:"+validCode);
        Scanner sc = new Scanner(System.in);
        String inputStr = sc.next();
        
        if(inputStr.compareToIgnoreCase(validCode) == 0) {
            System.out.println("验证码正确");
        }else {
            System.out.println("验证码错误");
        }*/
        
        System.out.println(str1.contentEquals(str2));
        System.out.println(str1.equals(str2));
        System.out.println(str1.equalsIgnoreCase(str2));
    }

CharSequence 接口把字符串看出一个可读序列,提供了charAt(index)获取指定索引处的字符；length() 字符数组或者字符串的长度。

 [3]查找、搜索字符串

public static void main(String[] args) {
        // 【3】查找、搜索字符串中是否包含其他子串
        String str1 = "hello world";
        
        // 是否包含子串
        System.out.println(str1.contains("world"));
        
        System.out.println(str1.startsWith("he"));
        System.out.println(str1.endsWith("world"));
        System.out.println(str1.startsWith("ll", 2));
    
        // 需求:判断一个文件是否是png图片
        String fileName = "logo.png";
        if(fileName.endsWith(".png")) {
            System.out.println(fileName+"是一张图片");
        }
        
        
        // 查找字符串
        String str2 = "hello world hello";
        // 从左向右查找字符'o'第一次出现的位置,找到返回索引，没找到返回-1
        System.out.println(str2.indexOf('t'));
        System.out.println(str2.indexOf('o',5));
        // 从左向右查找字符串“ll”第一次出现的位置,找到返回索引，没找到返回-1
        System.out.println(str2.indexOf("ll"));
        System.out.println(str2.indexOf("ll",5));
        
        // 从右向左查找字符'o'第一次出现的位置,找到返回索引，没找到返回-1
        System.out.println(str2.lastIndexOf('o'));
        // lastIndex(char,fromIndex)
        // lastIndex(string);
        // lastIndex(string,fromIndex);
    }

[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));
        System.out.println(str1);
        // 四舍五入保留两位小数
        String str2  =String.format("$%.2f", price);
        System.out.println(str2);
    }

[5] 把字符串按指定编码集编码成对于的字节序列

    String str3 = "abc";
        String str3 = "中国";        
        // 使用默认的字符集（GBK）
        byte[] byte1 = str3.getBytes();
        System.out.println(Arrays.toString(byte1));
        
        
        //String str4 = "abc";
        String str4 = "中国";    
        // 使用utf8编码
        byte[] bytes2 = str4.getBytes("UTF-8");
        System.out.println(Arrays.toString(bytes2));

[6]替换字符串

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);
        
        // 需求:186-1234-2234
        String str3 = "186-1234-2234";
        System.out.println(str3.replace("-", ""));
        
        // 正则表达式专门用于验证字符串是否符合特定的格式。
        String str4 = "6764";
        // 验证str4是否输入的是一串数字
        boolean r = str4.matches("\d+");
        System.out.println(r);
        
        // 需求:abc123te23daf去掉数字
        String str5 = "abc123te23daf";
//        String newStr5 = str5.replaceAll("\d+", "");
        String newStr5 = str5.replaceFirst("\d+", "");
        System.out.println(newStr5);
        
    }

[7]拆分字符串

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));
        
        // 根据正则拆分字符串
        String str3 = "abc123ta12asd";
        String[] arr3 = str3.split("\d+");
        System.out.println(Arrays.toString(arr3));
        
        
        // 需求:请获取一个文件的文件名
        String fileName = "logo.png";
        String[] arr4 = fileName.split("\.");
        System.out.println(Arrays.toString(arr4));
        
    }

[8] 求子串、大小写转换

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

[9]其他方法

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

1.4 StringBuffer

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

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

 StringBuffer 是线程安全的

1.4.1 StringBuffer工作原理

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

1.5.2 常用方法

package cn.sxt03.string02;

public class Test01 {
    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);
    }
}

1.5 StringBuilder

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

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